html

package
v0.0.0-...-81fcc2c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 28, 2022 License: Apache-2.0 Imports: 19 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	KNewElementIsUndefined = "div.NewDiv().error: new element is undefined:"
	KIdToAppendNotFound    = "html.AppendById().error: id to append not found:"
)

Variables

This section is empty.

Functions

func RGBAToJs 

func RGBAToJs(color color.RGBA) string

Types

type AdjacentPosition 

type AdjacentPosition string
const (
	// KAdjacentPositionBeforeBegin
	//
	// English:
	//
	//  Before the element. Only valid if the element is in the DOM tree and has a parent element.
	//
	// Português:
	//
	//  Antes do elemento. Válido apenas se o elemento estiver na árvore DOM e tiver um elemento pai.
	KAdjacentPositionBeforeBegin AdjacentPosition = "beforebegin"

	// KAdjacentPositionAfterBegin
	//
	// English:
	//
	//  Just inside the element, before its first child.
	//
	// Português:
	//
	//  Apenas dentro do elemento, antes de seu primeiro filho.
	KAdjacentPositionAfterBegin AdjacentPosition = "afterbegin"

	// KAdjacentPositionBeforeEnd
	//
	// English:
	//
	//  Just inside the element, after its last child.
	//
	// Português:
	//
	//  Apenas dentro do elemento, após seu último filho.
	KAdjacentPositionBeforeEnd AdjacentPosition = "beforeend"

	// KAdjacentPositionAfterEnd
	//
	// english:
	//
	//  After the element. Only valid if the element is in the DOM tree and has a parent element.
	//
	// Português:
	//
	//  Depois do elemento. Válido apenas se o elemento estiver na árvore DOM e tiver um elemento pai.
	KAdjacentPositionAfterEnd AdjacentPosition = "afterend"
)

func (AdjacentPosition) String 

func (e AdjacentPosition) String() string

type Autocomplete 

type Autocomplete string
const (
	// KAutocompleteOff
	//
	// English:
	//
	//  The browser is not permitted to automatically enter or select a value for this field. It is
	//  possible that the document or application provides its own autocomplete feature, or that
	//  security concerns require that the field's value not be automatically entered.
	//
	//   Note:
	//     * In most modern browsers, setting autocomplete to "off" will not prevent a password manager
	//       from asking the user if they would like to save username and password information, or from
	//       automatically filling in those values in a site's login form. See the autocomplete
	//       attribute and login fields.
	//
	// Português:
	//
	//  O navegador não tem permissão para inserir ou selecionar automaticamente um valor para este
	//  campo. É possível que o documento ou aplicativo forneça seu próprio recurso de preenchimento
	//  automático ou que questões de segurança exijam que o valor do campo não seja inserido
	//  automaticamente.
	//
	//   Nota:
	//     * Na maioria dos navegadores modernos, definir o preenchimento automático como "desativado"
	//       não impedirá que um gerenciador de senhas pergunte ao usuário se ele deseja salvar as
	//       informações de nome de usuário e senha ou de preencher automaticamente esses valores no
	//       formulário de login de um site. Consulte o atributo de preenchimento automático e os
	//       campos de login.
	KAutocompleteOff Autocomplete = "off"

	// KAutocompleteOn
	//
	// English:
	//
	//  The browser is allowed to automatically complete the input. No guidance is provided as to the
	//  type of data expected in the field, so the browser may use its own judgement.
	//
	// Português:
	//
	//  O navegador tem permissão para completar automaticamente a entrada. Nenhuma orientação é
	//  fornecida quanto ao tipo de dados esperados no campo, portanto, o navegador pode usar seu
	//  próprio julgamento.
	KAutocompleteOn Autocomplete = "on"

	// KAutocompleteName
	//
	// English:
	//
	//  The field expects the value to be a person's full name. Using "name" rather than breaking the
	//  name down into its components is generally preferred because it avoids dealing with the wide
	//  diversity of human names and how they are structured; however, you can use the following
	//  autocomplete values if you do need to break the name down into its components
	//
	// Português:
	//
	//  O campo espera que o valor seja o nome completo de uma pessoa. Usar "nome" em vez de dividir o
	//  nome em seus componentes é geralmente preferido porque evita lidar com a grande diversidade de
	//  nomes humanos e como eles são estruturados; no entanto, você pode usar os seguintes valores de
	//  preenchimento automático se precisar dividir o nome em seus componentes
	KAutocompleteName Autocomplete = "name"

	// KAutocompleteHonorificPrefix
	//
	// English:
	//
	//  The prefix or title, such as "Mrs.", "Mr.", "Miss", "Ms.", "Dr.", or "Mlle.".
	//
	// Português:
	//
	//  O prefixo ou título, como "Mrs.", "Mr.", "Miss", "Ms.", "Dr." ou "Mlle.".
	KAutocompleteHonorificPrefix Autocomplete = "honorific-prefix"

	// KAutocompleteGivenName
	//
	// English:
	//
	//  The given (or "first") name.
	//
	// Português:
	//
	//  O primeiro nome.
	KAutocompleteGivenName Autocomplete = "given-name"

	// KAutocompleteAdditionalName
	//
	// English:
	//
	//  The middle name.
	//
	// Português:
	//
	//  O nome do meio.
	KAutocompleteAdditionalName Autocomplete = "additional-name"

	// KAutocompleteFamilyName
	//
	// English:
	//
	//  The family (or "last") name.
	//
	// Português:
	//
	//  Sobrenome
	KAutocompleteFamilyName Autocomplete = "family-name"

	// KAutocompleteHonorificSuffix
	//
	// English:
	//
	//  The suffix, such as "Jr.", "B.Sc.", "PhD.", "MBASW", or "IV".
	//
	// Português:
	//
	//  O sufixo, como "Jr.", "B.Sc.", "PhD.", "MBASW" ou "IV".
	KAutocompleteHonorificSuffix Autocomplete = "honorific-suffix"

	// KAutocompleteNickname
	//
	// English:
	//
	//  A nickname or handle.
	//
	// Português:
	//
	//  Um apelido ou identificador.
	KAutocompleteNickname Autocomplete = "nickname"

	// KAutocompleteEmail
	//
	// English:
	//
	//  An email address.
	//
	// Português:
	//
	//  Um endereço de e-mail.
	KAutocompleteEmail Autocomplete = "email"

	// KAutocompleteUsername
	//
	// English:
	//
	//  A username or account name.
	//
	// Português:
	//
	//  Um nome de usuário.
	KAutocompleteUsername Autocomplete = "username"

	// KAutocompleteNewPassword
	//
	// English:
	//
	//  A new password. When creating a new account or changing passwords, this should be used for an
	//  "Enter your new password" or "Confirm new password" field, as opposed to a general "Enter your
	//  current password" field that might be present. This may be used by the browser both to avoid
	//  accidentally filling in an existing password and to offer assistance in creating a secure
	//  password (see also Preventing autofilling with autocomplete="new-password").
	//
	// Português:
	//
	//  Uma nova senha. Ao criar uma nova conta ou alterar senhas, isso deve ser usado para um campo
	//  "Digite sua nova senha" ou "Confirme nova senha", em vez de um campo geral "Digite sua senha
	//  atual" que pode estar presente. Isso pode ser usado pelo navegador tanto para evitar o
	//  preenchimento acidental de uma senha existente quanto para oferecer assistência na criação de
	//  uma senha segura (consulte também Impedindo o preenchimento automático com
	//  autocomplete="new-password").
	KAutocompleteNewPassword Autocomplete = "new-password"

	// KAutocompleteCurrentPassword
	//
	// English:
	//
	//  The user's current password.
	//
	// Português:
	//
	//  A senha atual do usuário.
	KAutocompleteCurrentPassword Autocomplete = "current-password"

	// KAutocompleteOneTimeCode
	//
	// English:
	//
	//  A one-time code used for verifying user identity.
	//
	// Português:
	//
	//  Um código único usado para verificar a identidade do usuário.
	KAutocompleteOneTimeCode Autocomplete = "one-time-code"

	// KAutocompleteOrganizationTitle
	//
	// English:
	//
	//  A job title, or the title a person has within an organization, such as "Senior Technical
	//  Writer", "President", or "Assistant Troop Leader".
	//
	// Português:
	//
	//  Um cargo ou o título que uma pessoa tem dentro de uma organização, como "Escritor Técnico
	//  Sênior", "Presidente" ou "Líder de Tropa Assistente".
	KAutocompleteOrganizationTitle Autocomplete = "organization-title"

	// KAutocompleteOrganization
	//
	// English:
	//
	//  A company or organization name, such as "Acme Widget Company" or "Girl Scouts of America".
	//
	// Português:
	//
	//  Um nome de empresa ou organização, como "Acme Widget Company" ou "Girl Scouts of America".
	KAutocompleteOrganization Autocomplete = "organization"

	// KAutocompleteStreetAddress
	//
	// English:
	//
	//  A street address. This can be multiple lines of text, and should fully identify the location of
	//  the address within its second administrative level (typically a city or town), but should not
	//  include the city name, ZIP or postal code, or country name.
	//
	// Português:
	//
	//  Um endereço de rua. Isso pode ser várias linhas de texto e deve identificar totalmente o local
	//  do endereço em seu segundo nível administrativo (normalmente uma cidade ou vila), mas não deve
	//  incluir o nome da cidade, CEP ou código postal ou nome do país.
	KAutocompleteStreetAddress Autocomplete = "street-address"

	// KAutocompleteAddressLine1
	//
	// English:
	//
	//  Each individual line of the street address. These should only be present if the
	//  "street-address" is not present.
	//
	// Português:
	//
	//  Cada linha individual do endereço. Estes só devem estar presentes se o "endereço" não estiver
	//  presente.
	KAutocompleteAddressLine1 Autocomplete = "address-line1"

	// KAutocompleteAddressLine2
	//
	// English:
	//
	//  Each individual line of the street address. These should only be present if the
	//  "street-address" is not present.
	//
	// Português:
	//
	//  Cada linha individual do endereço. Estes só devem estar presentes se o "endereço" não estiver
	//  presente.
	KAutocompleteAddressLine2 Autocomplete = "address-line2"

	// KAutocompleteAddressLine3
	//
	// English:
	//
	//  Each individual line of the street address. These should only be present if the
	//  "street-address" is not present.
	//
	// Português:
	//
	//  Cada linha individual do endereço. Estes só devem estar presentes se o "endereço" não estiver
	//  presente.
	KAutocompleteAddressLine3 Autocomplete = "address-line3"

	// KAutocompleteAddressLevel4
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel4 Autocomplete = "address-level4"

	// KAutocompleteAddressLevel3
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel3 Autocomplete = "address-level3"

	// KAutocompleteAddressLevel2
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel2 Autocomplete = "address-level2"

	// KAutocompleteAddressLevel1
	//
	// English:
	//
	//  The finest-grained administrative level, in addresses which have four levels.
	//
	// Português:
	//
	//  O nível administrativo mais refinado, em endereços que têm quatro níveis.
	KAutocompleteAddressLevel1 Autocomplete = "address-level1"

	// KAutocompleteCountry
	//
	// English:
	//
	//  A country or territory code.
	//
	// Português:
	//
	//  Um código de país ou território.
	KAutocompleteCountry Autocomplete = "country"

	// KAutocompleteCountryName
	//
	// English:
	//
	//  A country or territory name.
	//
	// Português:
	//
	//  Um nome de país ou território.
	KAutocompleteCountryName Autocomplete = "country-name"

	// KAutocompletePostalCode
	//
	// English:
	//
	//  A postal code (in the United States, this is the ZIP code).
	//
	// Português:
	//
	//  Um código postal (nos Estados Unidos, este é o CEP).
	KAutocompletePostalCode Autocomplete = "postal-code"

	// KAutocompleteCcName
	//
	// English:
	//
	//  The full name as printed on or associated with a payment instrument such as a credit card.
	//  Using a full name field is preferred, typically, over breaking the name into pieces.
	//
	// Português:
	//
	//  O nome completo impresso ou associado a um instrumento de pagamento, como um cartão de crédito.
	//  Normalmente, é preferível usar um campo de nome completo em vez de dividir o nome em partes.
	KAutocompleteCcName Autocomplete = "cc-name"

	// KAutocompleteCcGivenName
	//
	// English:
	//
	//  A given (first) name as given on a payment instrument like a credit card.
	//
	// Português:
	//
	//  Primeiro nome dado em um instrumento de pagamento, como um cartão de crédito.
	KAutocompleteCcGivenName Autocomplete = "cc-given-name"

	// KAutocompleteCcAdditionalName
	//
	// English:
	//
	//  A middle name as given on a payment instrument or credit card.
	//
	// Português:
	//
	//  Nome do meio fornecido em um instrumento de pagamento ou cartão de crédito.
	KAutocompleteCcAdditionalName Autocomplete = "cc-additional-name"

	// KAutocompleteCcFamilyName
	//
	// English:
	//
	//  A family name, as given on a credit card.
	//
	// Português:
	//
	//  Nome de família, conforme fornecido em um cartão de crédito.
	KAutocompleteCcFamilyName Autocomplete = "cc-family-name"

	// KAutocompleteCcNumber
	//
	// English:
	//
	//  A credit card number or other number identifying a payment method, such as an account number.
	//
	// Português:
	//
	//  Um número de cartão de crédito ou outro número que identifique um método de pagamento, como um
	//  número de conta.
	KAutocompleteCcNumber Autocomplete = "cc-number"

	// KAutocompleteCcExp
	//
	// English:
	//
	//  A payment method expiration date, typically in the form "MM/YY" or "MM/YYYY".
	//
	// Português:
	//
	//  Uma data de expiração do método de pagamento, normalmente no formato "MM/YY" ou "MM/YYYY".
	KAutocompleteCcExp Autocomplete = "cc-exp"

	// KAutocompleteCcExpMonth
	//
	// English:
	//
	//  The month in which the payment method expires.
	//
	// Português:
	//
	//  O mês em que a forma de pagamento expira.
	KAutocompleteCcExpMonth Autocomplete = "cc-exp-month"

	// KAutocompleteCcExpYear
	//
	// English:
	//
	//  The year in which the payment method expires.
	//
	// Português:
	//
	//  O ano em que a forma de pagamento expira.
	KAutocompleteCcExpYear Autocomplete = "cc-exp-year"

	// KAutocompleteCcCsc
	//
	// English:
	//
	//  The security code for the payment instrument; on credit cards, this is the 3-digit verification
	//  number on the back of the card.
	//
	// Português:
	//
	//  O código de segurança do instrumento de pagamento; em cartões de crédito, este é o número de
	//  verificação de 3 dígitos no verso do cartão.
	KAutocompleteCcCsc Autocomplete = "cc-csc"

	// KAutocompleteCcType
	//
	// English:
	//
	// The type of payment instrument (such as "Visa" or "Master Card").
	//
	// Português:
	//
	// O tipo de instrumento de pagamento (como "Visa" ou "Master Card").
	KAutocompleteCcType Autocomplete = "cc-type"

	// KAutocompleteTransactionCurrency
	//
	// English:
	//
	//  The currency in which the transaction is to take place.
	//
	// Português:
	//
	//  A moeda em que a transação deve ocorrer.
	KAutocompleteTransactionCurrency Autocomplete = "transaction-currency"

	// KAutocompleteTransactionAmount
	//
	// English:
	//
	//  The amount, given in the currency specified by "transaction-currency", of the transaction,
	//  for a payment form.
	//
	// Português:
	//
	//  O valor, fornecido na moeda especificada por "moeda da transação", da transação, para um
	//  formulário de pagamento.
	KAutocompleteTransactionAmount Autocomplete = "transaction-amount"

	// KAutocompleteLanguage
	//
	// English:
	//
	//  A preferred language, given as a valid BCP 47 language tag.
	//
	// Português:
	//
	//  Um idioma preferencial, fornecido como uma tag de idioma BCP 47 válida.
	KAutocompleteLanguage Autocomplete = "language"

	// KAutocompleteBbday
	//
	// English:
	//
	//  A birth date, as a full date.
	//
	// Português:
	//
	//  Uma data de nascimento, como uma data completa.
	KAutocompleteBbday Autocomplete = "bday"

	// KAutocompleteBdayDay
	//
	// English:
	//
	//  The day of the month of a birth date.
	//
	// Português:
	//
	//  O dia do mês de uma data de nascimento.
	KAutocompleteBdayDay Autocomplete = "bday-day"

	// KAutocompleteBdayMonth
	//
	// English:
	//
	//  The month of the year of a birth date.
	//
	// Português:
	//
	//  O mês do ano de uma data de nascimento.
	KAutocompleteBdayMonth Autocomplete = "bday-month"

	// KAutocompleteBdayYear
	//
	// English:
	//
	//  The year of a birth date.
	//
	// Português:
	//
	//  O ano de uma data de nascimento.
	KAutocompleteBdayYear Autocomplete = "bday-year"

	// KAutocompleteSex
	//
	// English:
	//
	//  A gender identity (such as "Female", "Fa'afafine", "Male"), as freeform text without newlines.
	//
	// Português:
	//
	//  Uma identidade de gênero (como "Feminino", "Fa'afafine", "Masculino"), como texto de forma
	//  livre sem novas linhas.
	KAutocompleteSex Autocomplete = "sex"

	// KAutocompleteTel
	//
	// English:
	//
	//  A full telephone number, including the country code. If you need to break the phone number
	//  up into its components, you can use these values for those fields:
	//
	// Português:
	//
	//  Um número de telefone completo, incluindo o código do país. Se você precisar dividir o número
	//  de telefone em seus componentes, poderá usar estes valores para esses campos:
	KAutocompleteTel Autocomplete = "tel"

	// KAutocompleteTelCountryCode
	//
	// English:
	//
	//  The country code, such as "1" for the United States, Canada, and other areas in North America
	//  and parts of the Caribbean.
	//
	// Português:
	//
	//  O código do país, como "1" para os Estados Unidos, Canadá e outras áreas da América do Norte e
	//  partes do Caribe.
	KAutocompleteTelCountryCode Autocomplete = "tel-country-code"

	// KAutocompleteTelNational
	//
	// English:
	//
	//  The entire phone number without the country code component, including a country-internal
	//  prefix. For the phone number "1-855-555-6502", this field's value would be "855-555-6502".
	//
	// Português:
	//
	//  O número de telefone completo sem o componente de código do país, incluindo um prefixo interno
	//  do país. Para o número de telefone "1-855-555-6502", o valor desse campo seria "855-555-6502".
	KAutocompleteTelNational Autocomplete = "tel-national"

	// KAutocompleteTelAreaCode
	//
	// English:
	//
	//  The area code, with any country-internal prefix applied if appropriate.
	//
	// Português:
	//
	//  O código de área, com qualquer prefixo interno do país aplicado, se apropriado.
	KAutocompleteTelAreaCode Autocomplete = "tel-area-code"

	// KAutocompleteTelLocal
	//
	// English:
	//
	//  The phone number without the country or area code. This can be split further into two parts,
	//  for phone numbers which have an exchange number and then a number within the exchange. For the
	//  phone number "555-6502", use "tel-local-prefix" for "555" and "tel-local-suffix" for "6502".
	//
	// Português:
	//
	//  O número de telefone sem o código do país ou área. Isso pode ser dividido em duas partes, para
	//  números de telefone que têm um número de troca e, em seguida, um número dentro da troca. Para
	//  o número de telefone "555-6502", use "tel-local-prefix" para "555" e "tel-local-suffix"
	//  para "6502".
	KAutocompleteTelLocal Autocomplete = "tel-local"

	// KAutocompleteTelExtension
	//
	// English:
	//
	//  A telephone extension code within the phone number, such as a room or suite number in a hotel
	//  or an office extension in a company.
	//
	// Português:
	//
	//  Um código de ramal de telefone dentro do número de telefone, como um número de quarto ou suíte
	//  em um hotel ou um ramal de escritório em uma empresa.
	KAutocompleteTelExtension Autocomplete = "tel-extension"

	// KAutocompleteImpp
	//
	// English:
	//
	//  A URL for an instant messaging protocol endpoint, such as "xmpp:username@example.net".
	//
	// Português:
	//
	//  Um URL para um terminal de protocolo de mensagens instantâneas, como
	//  "xmpp:username@example.net".
	KAutocompleteImpp Autocomplete = "impp"

	// KAutocompleteUrl
	//
	// English:
	//
	//  A URL, such as a home page or company web site address as appropriate given the context of
	//  the other fields in the form.
	//
	// Português:
	//
	//  Um URL, como uma página inicial ou endereço do site da empresa, conforme apropriado,
	//  considerando o contexto dos outros campos do formulário.
	KAutocompleteUrl Autocomplete = "url"

	// KAutocompletePhoto
	//
	// English:
	//
	//  The URL of an image representing the person, company, or contact information given in the
	//  other fields in the form.
	//
	// Português:
	//
	//  O URL de uma imagem que representa a pessoa, empresa ou informações de contato fornecidas
	//  nos outros campos do formulário.
	KAutocompletePhoto Autocomplete = "photo"
)

func (Autocomplete) String 

func (e Autocomplete) String() string

type ButtonType 

type ButtonType string
const (
	// KButtonTypeSubmit
	//
	// English:
	//
	//  The button submits the form data to the server. This is the default if the attribute is not
	//  specified for buttons associated with a <form>, or if the attribute is an empty or invalid
	//  value.
	//
	// Português:
	//
	//  O botão envia os dados do formulário para o servidor. Este é o padrão se o atributo não for
	//  especificado para botões associados a um <form> ou se o atributo for um valor vazio ou inválido.
	KButtonTypeSubmit ButtonType = "submit"

	// KButtonTypeReset
	//
	// English:
	//
	//  The button resets all the controls to their initial values, like <input type="reset">.
	//  (This behavior tends to annoy users.)
	//
	// Português:
	//
	//  O botão redefine todos os controles para seus valores iniciais, como <input type="reset">.
	//  (Esse comportamento tende a incomodar os usuários.)
	KButtonTypeReset ButtonType = "reset"

	// KButtonTypeButton
	//
	// English:
	//
	//  The button has no default behavior, and does nothing when pressed by default. It can have
	//  client-side scripts listen to the element's events, which are triggered when the events occur.
	//
	// Português:
	//
	//  O botão não tem comportamento padrão e não faz nada quando pressionado por padrão. Ele pode
	//  fazer com que os scripts do lado do cliente escutem os eventos do elemento, que são acionados
	//  quando os eventos ocorrem.
	KButtonTypeButton ButtonType = "button"
)

func (ButtonType) String 

func (e ButtonType) String() string

type CanvasRepeatRule 

type CanvasRepeatRule string
const (
	// KRepeatRuleRepeat
	//
	// English:
	//
	//  (Default) The pattern repeats both horizontally and vertically.
	//
	// Português:
	//
	//  (Padrão) O padrão se repete horizontal e verticalmente.
	KRepeatRuleRepeat CanvasRepeatRule = "repeat"

	// KRepeatRuleRepeatX
	//
	// English:
	//
	//  The pattern repeats only horizontally.
	//
	// Português:
	//
	//  O padrão se repete apenas horizontalmente.
	KRepeatRuleRepeatX CanvasRepeatRule = "repeat-x"

	// KRepeatRuleRepeatY
	//
	// English:
	//
	//  The pattern repeats only vertically.
	//
	// Português:
	//
	//  O padrão se repete apenas verticalmente.
	KRepeatRuleRepeatY CanvasRepeatRule = "repeat-y"

	// KRepeatRuleNoRepeat
	//
	// English:
	//
	//  The pattern will be displayed only once (no repeat).
	//
	// Português:
	//
	//  The pattern will be displayed only once (no repeat).
	KRepeatRuleNoRepeat CanvasRepeatRule = "no-repeat"
)

func (CanvasRepeatRule) String 

func (e CanvasRepeatRule) String() string

type CapRule 

type CapRule string
const (
	// KCapRuleButt
	//
	// English:
	//
	//  (Default) A flat edge is added to each end of the line.
	//
	// Português:
	//
	//  (Padrão) Uma aresta plana é adicionada a cada extremidade da linha.
	KCapRuleButt CapRule = "butt"

	// KCapRuleRound
	//
	// English:
	//
	//  A rounded end cap is added to each end of the line.
	//
	// Português:
	//
	//  Uma tampa de extremidade arredondada é adicionada a cada extremidade da linha.
	KCapRuleRound CapRule = "round"

	// KCapRuleSquare
	//
	// English:
	//
	//  A square end cap is added to each end of the line.
	//
	// Português:
	//
	//  Uma tampa de extremidade quadrada é adicionada a cada extremidade da linha.
	KCapRuleSquare CapRule = "square"
)

func (CapRule) String 

func (e CapRule) String() string

type CompositeOperationsRule 

type CompositeOperationsRule string
const (
	// KCompositeOperationsRuleSourceOver
	//
	// English:
	//
	//  (Default) Displays the source image over the destination image.
	//
	// Português:
	//
	//  (Padrão) Exibe a imagem de origem sobre a imagem de destino.
	KCompositeOperationsRuleSourceOver CompositeOperationsRule = "source-over"

	// KCompositeOperationsRuleSourceAtop
	//
	// English:
	//
	//  Displays the source image on top of the destination image. The part of the source image that is
	//  outside the destination image is not shown.
	//
	// Português:
	//
	//  Exibe a imagem de origem sobre a imagem de destino. A parte da imagem de origem que está fora
	//  da imagem de destino não é mostrada.
	KCompositeOperationsRuleSourceAtop CompositeOperationsRule = "source-atop"

	// KCompositeOperationsRuleSourceIn
	//
	// English:
	//
	//  Displays the source image in to the destination image. Only the part of the source image that is
	//  INSIDE the destination image is shown, and the destination image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de origem na imagem de destino. Apenas a parte da imagem de origem que está
	//  DENTRO da imagem de destino é mostrada, e a imagem de destino é transparente.
	KCompositeOperationsRuleSourceIn CompositeOperationsRule = "source-in"

	// KCompositeOperationsRuleSourceOut
	//
	// English:
	//
	//  Displays the source image out of the destination image. Only the part of the source image that
	//  is OUTSIDE the destination image is shown, and the destination image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de origem fora da imagem de destino. Apenas a parte da imagem de origem que está
	//  FORA da imagem de destino é mostrada, e a imagem de destino é transparente.
	KCompositeOperationsRuleSourceOut CompositeOperationsRule = "source-out"

	// KCompositeOperationsRuleDestinationOver
	//
	// English:
	//
	//  Displays the destination image over the source image.
	//
	// Português:
	//
	//  Exibe a imagem de destino sobre a imagem de origem.
	KCompositeOperationsRuleDestinationOver CompositeOperationsRule = "destination-over"

	// KCompositeOperationsRuleDestinationAtop
	//
	// English:
	//
	//  Displays the destination image on top of the source image. The part of the destination image
	//  that is outside the source image is not shown.
	//
	// Português:
	//
	//  Exibe a imagem de destino sobre a imagem de origem. A parte da imagem de destino que está fora
	//  da imagem de origem não é mostrada.
	KCompositeOperationsRuleDestinationAtop CompositeOperationsRule = "destination-atop"

	// KCompositeOperationsRuleDestinationIn
	//
	// English:
	//
	//  Displays the destination image in to the source image. Only the part of the destination image
	//  that is INSIDE the source image is shown, and the source image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de destino na imagem de origem. Apenas a parte da imagem de destino que está
	//  DENTRO da imagem de origem é mostrada, e a imagem de origem é transparente.
	KCompositeOperationsRuleDestinationIn CompositeOperationsRule = "destination-in"

	// KCompositeOperationsRuleDestinationOut
	//
	// English:
	//
	//  Displays the destination image out of the source image. Only the part of the destination image
	//  that is OUTSIDE the source image is shown, and the source image is transparent.
	//
	// Português:
	//
	//  Exibe a imagem de destino fora da imagem de origem. Apenas a parte da imagem de destino que está
	//  FORA da imagem de origem é mostrada, e a imagem de origem é transparente.
	KCompositeOperationsRuleDestinationOut CompositeOperationsRule = "destination-out"

	// KCompositeOperationsRuleLighter
	//
	// English:
	//
	//  Displays the source image + the destination image.
	//
	// Português:
	//
	//  Exibe a imagem de origem + a imagem de destino.
	KCompositeOperationsRuleLighter CompositeOperationsRule = "lighter"

	// KCompositeOperationsRuleCopy
	//
	// English:
	//
	//  Displays the source image. The destination image is ignored.
	//
	// Português:
	//
	//  Exibe a imagem de origem. A imagem de destino é ignorada.
	KCompositeOperationsRuleCopy CompositeOperationsRule = "copy"

	// KCompositeOperationsRuleXor
	//
	// English:
	//
	//  The source image is combined by using an exclusive OR with the destination image.
	//
	// Português:
	//
	//  A imagem de origem é combinada usando um OR exclusivo com a imagem de destino.
	KCompositeOperationsRuleXor CompositeOperationsRule = "xor"
)

func (CompositeOperationsRule) String 

func (e CompositeOperationsRule) String() string

type CrossOrigin 

type CrossOrigin string
const (
	// KCrossOriginAnonymous
	//
	// English:
	//
	//  A CORS request is sent with credentials omitted (that is, no cookies, X.509 certificates, or
	//  Authorization request header).
	//
	// Português:
	//
	//  Uma solicitação CORS é enviada com credenciais omitidas (ou seja, sem cookies, certificados
	//  X.509 ou cabeçalho de solicitação de autorização).
	KCrossOriginAnonymous CrossOrigin = "anonymous"

	// KCrossOriginUseCredentials
	//
	// English:
	//
	//  The CORS request is sent with any credentials included (that is, cookies, X.509 certificates,
	//  and the Authorization request header).
	//
	// If the server does not opt into sharing credentials with the origin site (by sending back the
	// Access-Control-Allow-Credentials: true response header), then the browser marks the image as
	// tainted and restricts access to its image data.
	//
	// If the attribute has an invalid value, browsers handle it as if the anonymous value was used.
	// See CORS settings attributes for additional information.
	//
	// Português:
	//
	//  A solicitação CORS é enviada com todas as credenciais incluídas (ou seja, cookies, certificados
	//  X.509 e o cabeçalho da solicitação de autorização).
	//
	// Se o servidor não optar por compartilhar credenciais com o site de origem (enviando de volta o
	// cabeçalho Access-Control-Allow-Credentials: true response), o navegador marcará a imagem como
	// contaminada e restringirá o acesso aos dados da imagem.
	//
	// Se o atributo tiver um valor inválido, os navegadores o tratarão como se o valor anônimo fosse
	// usado. Consulte Atributos de configurações do CORS para obter informações adicionais.
	KCrossOriginUseCredentials CrossOrigin = "use-credentials"
)

func (CrossOrigin) String 

func (e CrossOrigin) String() string

type Decoding 

type Decoding string
const (
	// KDecodingSync
	//
	// English:
	//
	//  Decode the image synchronously, for atomic presentation with other content.
	//
	// Português:
	//
	//  Decodifique a imagem de forma síncrona, para apresentação atômica com outro conteúdo.
	KDecodingSync Decoding = "sync"

	// KDecodingAsync
	//
	// English:
	//
	//  Decode the image asynchronously, to reduce delay in presenting other content.
	//
	// Português:
	//
	//  Decodifique a imagem de forma assíncrona, para reduzir o atraso na apresentação de outros
	//  conteúdos.
	KDecodingAsync Decoding = "async"

	// KDecodingAuto
	//
	// English:
	//
	//  No preference for the decoding mode. The browser decides what is best for the user. (Default)
	//
	// Português:
	//
	//  Sem preferência para o modo de decodificação. O navegador decide o que é melhor para o usuário.
	//  (Padrão)
	KDecodingAuto Decoding = "auto"
)

func (Decoding) String 

func (e Decoding) String() string

type Dir 

type Dir string

Dir

English: 

Specifies the text direction for the content in an element.

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

const (
	// KDirLeftToRight
	//
	// English:
	//
	//  Default. Left-to-right text direction.
	//
	// Português:
	//
	//  Padrão. Direção do texto da esquerda para a direita.
	KDirLeftToRight Dir = "ltr"

	// KDirRightToLeft
	//
	// English:
	//
	//  Right-to-left text direction.
	//
	// Português:
	//
	//  Direção do texto da direita para a esquerda.
	KDirRightToLeft Dir = "rtl"

	// KDirAuto
	//
	// English:
	//
	//  Let the browser figure out the text direction, based on the content (only recommended if the
	//  text direction is unknown)
	//
	// Português:
	//
	//  Deixe o navegador descobrir a direção do texto, com base no conteúdo (recomendado apenas se a
	//  direção do texto for desconhecida)
	KDirAuto Dir = "auto"
)

func (Dir) String 

func (e Dir) String() (element string)

type Draggable 

type Draggable string

Draggable

English: 

Specifies whether an element is draggable or not

Português: 

Especifica se um elemento pode ser arrastado ou não

const (
	// KDraggableYes
	//
	// English:
	//
	//  Specifies that the element is draggable.
	//
	// Português:
	//
	//  Especifica que o elemento pode ser arrastado.
	KDraggableYes Draggable = "true"

	// KDraggableNo
	//
	// English:
	//
	//  Specifies that the element is not draggable.
	//
	// Português:
	//
	//  Especifica que o elemento não pode ser arrastado.
	KDraggableNo Draggable = "false"

	// KDraggableAuto
	//
	// English:
	//
	//  Uses the default behavior of the browser.
	//
	// Português:
	//
	//  Usa o comportamento padrão do navegador.
	KDraggableAuto Draggable = "auto"
)

func (Draggable) String 

func (e Draggable) String() (element string)

type EnterKeyHint 

type EnterKeyHint string
const (
	// EnterKeyHintEnter
	//
	// English:
	//
	//  typically indicating inserting a new line.
	//
	// Português:
	//
	//  normalmente indicando a inserção de uma nova linha.
	EnterKeyHintEnter EnterKeyHint = "enter"

	// EnterKeyHintDone
	//
	// English:
	//
	//  Typically meaning there is nothing more to input and the input method editor (IME) will be
	//  closed.
	//
	// Português:
	//
	//  Normalmente, significa que não há mais nada para inserir e o editor de método de entrada (IME)
	//  será fechado.
	EnterKeyHintDone EnterKeyHint = "done"

	// EnterKeyHintGo
	//
	// English:
	//
	//  Typically meaning to take the user to the target of the text they typed.
	//
	// Português:
	//
	//  Normalmente significa levar o usuário ao destino do texto digitado.
	EnterKeyHintGo EnterKeyHint = "go"

	// EnterKeyHintNext
	//
	// English:
	//
	//  Typically taking the user to the next field that will accept text.
	//
	// Português:
	//
	//  Normalmente levando o usuário para o próximo campo que aceitará texto.
	EnterKeyHintNext EnterKeyHint = "next"

	// EnterKeyHintPrevious
	//
	// English:
	//
	//  Typically taking the user to the previous field that will accept text.
	//
	// Português:
	//
	//  Normalmente levando o usuário ao campo anterior que aceitará texto.
	EnterKeyHintPrevious EnterKeyHint = "previous"

	// EnterKeyHintSearch
	//
	// English:
	//
	//  Typically taking the user to the results of searching for the text they have typed.
	//
	// Português:
	//
	//  Normalmente, leva o usuário aos resultados da pesquisa do texto que digitou.
	EnterKeyHintSearch EnterKeyHint = "search"

	// EnterKeyHintSend
	//
	// English:
	//
	//  Typically delivering the text to its target.
	//
	// Português:
	//
	//  Normalmente entregando o texto ao seu destino.
	EnterKeyHintSend EnterKeyHint = "send"
)

func (EnterKeyHint) String 

func (e EnterKeyHint) String() string

type FetchPriority 

type FetchPriority string
const (
	// KFetchPriorityHigh
	//
	// English:
	//
	//  Signals a high-priority fetch relative to other images.
	//
	// Português:
	//
	//  Sinaliza uma busca de alta prioridade em relação a outras imagens.
	KFetchPriorityHigh FetchPriority = "high"

	// KFetchPriorityLow
	//
	// English:
	//
	//  Signals a low-priority fetch relative to other images.
	//
	// Português:
	//
	//  Sinaliza uma busca de baixa prioridade em relação a outras imagens.
	KFetchPriorityLow FetchPriority = "low"

	// KFetchPriorityAuto
	//
	// English:
	//
	//  Signals automatic determination of fetch priority relative to other images.
	//
	// Português:
	//
	//  Sinaliza a determinação automática da prioridade de busca em relação a outras imagens.
	KFetchPriorityAuto FetchPriority = "auto"
)

func (FetchPriority) String 

func (e FetchPriority) String() string

type FillRule 

type FillRule string
const (
	// KFillRuleNonZero
	//
	// English:
	//
	//  In two-dimensional computer graphics, the non-zero winding rule is a means of determining
	//  whether a given point falls within an enclosed curve. Unlike the similar even-odd rule, it
	//  relies on knowing the direction of stroke for each part of the curve.
	//
	// Português:
	//
	//  Em computação gráfica bidimensional, a regra de enrolamento diferente de zero é um meio de
	//  determinar se um determinado ponto está dentro de uma curva fechada. Ao contrário da regra
	//  par-ímpar semelhante, ela depende do conhecimento da direção do curso para cada parte da curva.
	KFillRuleNonZero FillRule = "nonzero"

	// KFillRuleEvenOdd
	//
	// English:
	//
	//  The even–odd rule is an algorithm implemented in vector-based graphic software,[1] like the
	//  PostScript language and Scalable Vector Graphics (SVG), which determines how a graphical shape
	//  with more than one closed outline will be filled. Unlike the nonzero-rule algorithm, this
	//  algorithm will alternatively color and leave uncolored shapes defined by nested closed paths
	//  irrespective of their winding.
	//
	// Português:
	//
	//  A regra par-ímpar é um algoritmo implementado em software gráfico baseado em vetor,[1] como a
	//  linguagem PostScript e Scalable Vector Graphics (SVG), que determina como uma forma gráfica com
	//  mais de um contorno fechado será preenchida. Ao contrário do algoritmo de regra diferente de
	//  zero, esse algoritmo alternadamente colorirá e deixará formas não coloridas definidas por
	//  caminhos fechados aninhados, independentemente de seu enrolamento.
	KFillRuleEvenOdd FillRule = "evenodd"
)

func (FillRule) String 

func (e FillRule) String() string

type Font 

type Font struct {
	//Style
	//
	// English:
	//
	//  Specifies the font style.
	//
	// Português:
	//
	//  Especifica o estilo da fonte.
	Style FontStyleRule

	// Variant
	//
	// English:
	//
	//  Specifies the font variant.
	//
	// Português:
	//
	//  Especifica a variante da fonte.
	Variant FontVariantRule

	// Weight
	//
	// English:
	//
	//  Specifies the font weight.
	//
	// Português:
	//
	//  Especifica o peso da fonte.
	Weight FontWeightRule

	// Size
	//
	// English:
	//
	//  Specifies the font size and the line-height, in pixels.
	//
	// Português:
	//
	//  Especifica o tamanho da fonte e a altura da linha, em pixels.
	Size int

	// Family
	//
	// English:
	//
	//  Specifies the font family.
	//
	// Português:
	//
	//  Especifica a família de fontes.
	Family string

	// Caption
	//
	// English:
	//
	//  Use the font captioned controls (like buttons, drop-downs, etc.)
	//
	// Português:
	//
	//  Use os controles legendados de fonte (como botões, menus suspensos etc.)
	Caption string

	// Icon
	//
	// English:
	//
	//  Use the font used to label icons.
	//
	// Português:
	//
	//  Use a fonte usada para rotular os ícones.
	Icon string

	// Menu
	//
	// English:
	//
	//  Use the font used in menus (drop-down menus and menu lists).
	//
	// Português:
	//
	//  Use a fonte usada nos menus (menus suspensos e listas de menus).
	Menu string

	// MessageBox
	//
	// English:
	//
	//  Use the font used in dialog boxes.
	//
	// Português:
	//
	//  Use a fonte usada nas caixas de diálogo.
	MessageBox string

	// SmallCaption
	//
	// English:
	//
	//  Use the font used for labeling small controls.
	//
	// Português:
	//
	//  Use a fonte usada para rotular pequenos controles.
	SmallCaption string

	// StatusBar
	//
	// English:
	//
	//  Use the fonts used in window status bar.
	//
	// Português:
	//
	//  Use as fontes usadas na barra de status da janela.
	StatusBar string
}

func (*Font) String 

func (e *Font) String() string

type FontAlignRule 

type FontAlignRule string
const (
	// KFontAlignRuleStart
	//
	// English:
	//
	//  (Default) The text starts at the specified position.
	//
	// Português:
	//
	//  (Padrão) O texto começa na posição especificada.
	KFontAlignRuleStart FontAlignRule = "start"

	// KFontAlignRuleEnd
	//
	// English:
	//
	//  The text ends at the specified position.
	//
	// Português:
	//
	//  O texto termina na posição especificada.
	KFontAlignRuleEnd FontAlignRule = "end"

	// KFontAlignRuleCenter
	//
	// English:
	//
	//  The center of the text is placed at the specified position.
	//
	// Português:
	//
	//  O centro do texto é colocado na posição especificada.
	KFontAlignRuleCenter FontAlignRule = "center"

	// KFontAlignRuleLeft
	//
	// English:
	//
	//  The text starts at the specified position.
	//
	// Português:
	//
	//  O texto começa na posição especificada.
	KFontAlignRuleLeft FontAlignRule = "left"

	// KFontAlignRuleRight
	//
	// English:
	//
	//  The text ends at the specified position.
	//
	// Português:
	//
	//  O texto termina na posição especificada.
	KFontAlignRuleRight FontAlignRule = "right"
)

func (FontAlignRule) String 

func (e FontAlignRule) String() string

type FontStyleRule 

type FontStyleRule string
const (
	// KFontStyleRuleNormal
	//
	// English:
	//
	//  Specifies the font style normal.
	//
	// Português:
	//
	//  Especifica o estilo de fonte normal.
	KFontStyleRuleNormal FontStyleRule = "normal"

	// KFontStyleRuleItalic
	//
	// English:
	//
	//  Specifies the font style italic.
	//
	// Português:
	//
	//  Especifica o estilo de fonte em itálico.
	KFontStyleRuleItalic FontStyleRule = "italic"

	// KFontStyleRuleOblique
	//
	// English:
	//
	//  Specifies the font style oblique.
	//
	// Português:
	//
	//  Especifica o estilo de fonte oblíquo.
	KFontStyleRuleOblique FontStyleRule = "oblique"
)

func (FontStyleRule) String 

func (e FontStyleRule) String() string

type FontVariantRule 

type FontVariantRule string
const (
	// KFontVariantRuleNormal
	//
	// English:
	//
	//  Specifies the font variant normal.
	//
	// Português:
	//
	//  Especifica a variante de fonte normal.
	KFontVariantRuleNormal FontVariantRule = "normal"

	// KFontVariantRuleSmallCaps
	//
	// English:
	//
	//  Specifies the font variant small-caps.
	//
	// Português:
	//
	//  Especifica as letras minúsculas da variante da fonte.
	KFontVariantRuleSmallCaps FontVariantRule = "small-caps"
)

func (FontVariantRule) String 

func (e FontVariantRule) String() string

type FontWeightRule 

type FontWeightRule string
const (
	// KFontWeightRuleNormal
	//
	// English:
	//
	//  Specifies the font weight normal.
	//
	// Português:
	//
	//  Especifica o peso da fonte normal.
	KFontWeightRuleNormal FontWeightRule = "normal"

	// KFontWeightRuleBold
	//
	// English:
	//
	//  Specifies the font weight bold.
	//
	// Português:
	//
	//  Especifica a espessura da fonte em negrito.
	KFontWeightRuleBold FontWeightRule = "bold"

	// KFontWeightRuleBolder
	//
	// English:
	//
	//  Specifies the font weight bolder.
	//
	// Português:
	//
	//  Especifica o peso da fonte em negrito.
	KFontWeightRuleBolder FontWeightRule = "bolder"

	// KFontWeightRuleLighter
	//
	// English:
	//
	//  Specifies the font weight lighter.
	//
	// Português:
	//
	//  Especifica o peso da fonte mais leve.
	KFontWeightRuleLighter FontWeightRule = "lighter"

	// KFontWeightRule100
	//
	// English:
	//
	//  Specifies the font weight 100.
	//
	// Português:
	//
	//  Especifica o peso da fonte 100.
	KFontWeightRule100 FontWeightRule = "100"

	// KFontWeightRule200
	//
	// English:
	//
	//  Specifies the font weight 200.
	//
	// Português:
	//
	//  Especifica o peso da fonte 200.
	KFontWeightRule200 FontWeightRule = "200"

	// KFontWeightRule300
	//
	// English:
	//
	//  Specifies the font weight 300.
	//
	// Português:
	//
	//  Especifica o peso da fonte 300.
	KFontWeightRule300 FontWeightRule = "300"

	// KFontWeightRule400
	//
	// English:
	//
	//  Specifies the font weight 400.
	//
	// Português:
	//
	//  Especifica o peso da fonte 400.
	KFontWeightRule400 FontWeightRule = "400"

	// KFontWeightRule500
	//
	// English:
	//
	//  Specifies the font weight 500.
	//
	// Português:
	//
	//  Especifica o peso da fonte 500.
	KFontWeightRule500 FontWeightRule = "500"

	// KFontWeightRule600
	//
	// English:
	//
	//  Specifies the font weight 600.
	//
	// Português:
	//
	//  Especifica o peso da fonte 600.
	KFontWeightRule600 FontWeightRule = "600"

	// KFontWeightRule700
	//
	// English:
	//
	//  Specifies the font weight 700.
	//
	// Português:
	//
	//  Especifica o peso da fonte 700.
	KFontWeightRule700 FontWeightRule = "700"

	// KFontWeightRule800
	//
	// English:
	//
	//  Specifies the font weight 800.
	//
	// Português:
	//
	//  Especifica o peso da fonte 800.
	KFontWeightRule800 FontWeightRule = "800"

	// KFontWeightRule900
	//
	// English:
	//
	//  Specifies the font weight 900.
	//
	// Português:
	//
	//  Especifica o peso da fonte 900.
	KFontWeightRule900 FontWeightRule = "900"
)

func (FontWeightRule) String 

func (e FontWeightRule) String() string

type FormEncType 

type FormEncType string
const (
	// KFormEncTypeApplication
	//
	// English:
	//
	//  The default if the attribute is not used.
	//
	// Português:
	//
	//  O padrão se o atributo não for usado.
	KFormEncTypeApplication FormEncType = "application/x-www-form-urlencoded"

	// KFormEncTypeMultiPart
	//
	// English:
	//
	//  Use to submit <input> elements with their type attributes set to file.
	//
	// Português:
	//
	//  Use para enviar elementos <input> com seus atributos de tipo definidos para arquivo.
	KFormEncTypeMultiPart FormEncType = "multipart/form-data"

	// KFormEncTypeText
	//
	// English:
	//
	//  Specified as a debugging aid; shouldn't be used for real form submission.
	//
	// Português:
	//
	//  Especificado como auxiliar de depuração; não deve ser usado para envio de formulário real.
	KFormEncTypeText FormEncType = "text/plain"
)

func (FormEncType) String 

func (e FormEncType) String() string

type FormMethod 

type FormMethod string
const (
	// KFormMethodPost
	//
	// English:
	//
	//  The data from the form are included in the body of the HTTP request when sent to the server.
	//  Use when the form contains information that shouldn't be public, like login credentials.
	//
	// Português:
	//
	//  Os dados do formulário são incluídos no corpo da solicitação HTTP quando enviados ao servidor.
	//  Use quando o formulário contém informações que não devem ser públicas, como credenciais de
	//  login.
	KFormMethodPost FormMethod = "post"

	// KFormMethodGet
	//
	// English:
	//
	//  The form data are appended to the form's action URL, with a ? as a separator, and the resulting
	//  URL is sent to the server. Use this method when the form has no side effects, like search forms.
	//
	// Português:
	//
	//  Os dados do formulário são anexados à URL de ação do formulário, com um ? como separador e a URL
	//  resultante é enviada ao servidor. Use este método quando o formulário não tiver efeitos
	//  colaterais, como formulários de pesquisa.
	KFormMethodGet FormMethod = "get"

	// KFormMethodDialog
	//
	// English:
	//
	//  When the form is inside a <dialog>, closes the dialog and throws a submit event on submission
	//  without submitting data or clearing the form.
	//
	// Português:
	//
	//  When the form is inside a <dialog>, closes the dialog and throws a submit event on submission
	//  without submitting data or clearing the form.
	KFormMethodDialog FormMethod = "dialog"
)

func (FormMethod) String 

func (e FormMethod) String() string

type InputMode 

type InputMode string
const (
	// KInputModeNone
	//
	// English:
	//
	//  No virtual keyboard. For when the page implements its own keyboard input control.
	//
	// Português:
	//
	//  Sem teclado virtual. Para quando a página implementa seu próprio controle de entrada de teclado.
	KInputModeNone InputMode = "none"

	// KInputModeText
	//
	// English:
	//
	//   Standard input keyboard for the user's current locale. (default)
	//
	// Português:
	//
	//  Teclado de entrada padrão para a localidade atual do usuário. (Padrão)
	KInputModeText InputMode = "text"

	// KInputModeDecimal
	//
	// English:
	//
	//  Fractional numeric input keyboard containing the digits and decimal separator for the user's
	//  locale (typically . or ,). Devices may or may not show a minus key (-).
	//
	// Português:
	//
	//  Teclado de entrada numérica fracionária contendo os dígitos e o separador decimal para a
	//  localidade do usuário (normalmente . ou ,). Os dispositivos podem ou não mostrar uma tecla
	//  de menos (-).
	KInputModeDecimal InputMode = "decimal"

	// KInputModeNumeric
	//
	// English:
	//
	//  Numeric input keyboard, but only requires the digits 0–9. Devices may or may not show a minus
	//  key.
	//
	// Português:
	//
	//  Teclado de entrada numérica, mas requer apenas os dígitos de 0 a 9. Os dispositivos podem ou
	//  não mostrar uma tecla de menos.
	KInputModeNumeric InputMode = "numeric"

	// KInputModeTel
	//
	// English:
	//
	//  A telephone keypad input, including the digits 0–9, the asterisk (*), and the pound (#) key.
	//  Inputs that *require* a telephone number should typically use <input type="tel"> instead.
	//
	// Português:
	//
	//  Uma entrada do teclado do telefone, incluindo os dígitos de 0 a 9, o asterisco (*) e a tecla
	//  sustenido (#). As entradas que exigem um número de telefone normalmente devem usar
	//  <input type="tel">.
	KInputModeTel InputMode = "tel"

	// KInputModeSearch
	//
	// English:
	//
	//  A virtual keyboard optimized for search input. For instance, the return/submit key may be
	//  labeled "Search", along with possible other optimizations. Inputs that require a search query
	//  should typically use <input type="search"> instead.
	//
	// Português:
	//
	//  Um teclado virtual otimizado para entrada de pesquisa. Por exemplo, a chave returnsubmit pode
	//  ser rotulada como "Search", juntamente com possíveis outras otimizações. As entradas que exigem
	//  uma consulta de pesquisa normalmente devem usar <input type="search">.
	KInputModeSearch InputMode = "search"

	// KInputModeEmail
	//
	// English:
	//
	//  A virtual keyboard optimized for entering email addresses. Typically includes the @character
	//  as well as other optimizations. Inputs that require email addresses should typically use
	//  <input type="email"> instead.
	//
	// Português:
	//
	//  Um teclado virtual otimizado para inserir endereços de e-mail. Normalmente inclui o @character,
	//  bem como outras otimizações. As entradas que exigem endereços de e-mail normalmente devem usar
	//  <input type="email">.
	KInputModeEmail InputMode = "email"

	// KInputModeUrl
	//
	// English:
	//
	//  A keypad optimized for entering URLs. This may have the / key more prominent, for example.
	//  Enhanced features could include history access and so on. Inputs that require a URL should
	//  typically use <input type="url"> instead.
	//
	// Português:
	//
	//  Um teclado otimizado para inserir URLs. Isso pode ter a chave mais proeminente, por exemplo.
	//  Recursos aprimorados podem incluir acesso ao histórico e assim por diante. As entradas que
	//  exigem um URL normalmente devem usar <input type="url">.
	KInputModeUrl InputMode = "url"
)

func (InputMode) String 

func (e InputMode) String() string

type InputType 

type InputType string
const (
	// KInputTypeButton
	//
	// English:
	//
	//  A push button with no default behavior displaying the value of the value attribute, empty by
	//  default.
	//
	// Português:
	//
	//  Um botão de ação sem comportamento padrão exibindo o valor do atributo value, vazio por padrão.
	KInputTypeButton InputType = "button"

	// KInputTypeCheckbox
	//
	// English:
	//
	//  A check box allowing single values to be selected/deselected.
	//
	// Português:
	//
	//  Uma caixa de seleção que permite que valores únicos sejam selecionados desmarcados.
	KInputTypeCheckbox InputType = "checkbox"

	// KInputTypeColor
	//
	// English:
	//
	//  A control for specifying a color; opening a color picker when active in supporting browsers.
	//
	// Português:
	//
	//  Um controle para especificar uma cor; abrindo um seletor de cores quando ativo em navegadores
	//  compatíveis.
	KInputTypeColor InputType = "color"

	// KInputTypeDate
	//
	// English:
	//
	//  A control for entering a date (year, month, and day, with no time). Opens a date picker or
	//  numeric wheels for year, month, day when active in supporting browsers.
	//
	// Português:
	//
	//  Um controle para inserir uma data (ano, mês e dia, sem hora). Abre um seletor de data ou rodas
	//  numéricas para ano, mês, dia quando ativo em navegadores compatíveis.
	KInputTypeDate InputType = "date"

	// KInputTypeDatetimeLocal
	//
	// English:
	//
	//  A control for entering a date and time, with no time zone. Opens a date picker or numeric
	//  wheels for date- and time-components when active in supporting browsers.
	//
	// Português:
	//
	//  Um controle para inserir uma data e hora, sem fuso horário. Abre um seletor de data ou rodas
	//  numéricas para componentes de data e hora quando ativo em navegadores compatíveis.
	KInputTypeDatetimeLocal InputType = "datetime-local"

	// KInputTypeEmail
	//
	// English:
	//
	//  A field for editing an email address. Looks like a text input, but has validation parameters and
	//  relevant keyboard in supporting browsers and devices with dynamic keyboards.
	//
	// Português:
	//
	//  Um campo para editar um endereço de e-mail. Parece uma entrada de texto, mas possui parâmetros
	//  de validação e teclado relevante no suporte a navegadores e dispositivos com teclados dinâmicos.
	KInputTypeEmail InputType = "email"

	// KInputTypeFile
	//
	// English:
	//
	//  A control that lets the user select a file. Use the accept attribute to define the types of
	//  files that the control can select.
	//
	// Português:
	//
	//  Um controle que permite ao usuário selecionar um arquivo. Use o atributo accept para definir os
	//  tipos de arquivos que o controle pode selecionar.
	KInputTypeFile InputType = "file"

	// KInputTypeHidden
	//
	// English:
	//
	//  A control that is not displayed but whose value is submitted to the server. There is an example
	//  in the next column, but it's hidden!
	//
	// Português:
	//
	//  Um controle que não é exibido, mas cujo valor é enviado ao servidor. Há um exemplo na próxima
	//  coluna, mas está oculto!
	KInputTypeHidden InputType = "hidden"

	// KInputTypeImage
	//
	// English:
	//
	//  A graphical submit button. Displays an image defined by the src attribute. The alt attribute
	//  displays if the image src is missing.
	//
	// Português:
	//
	//  Um botão de envio gráfico. Exibe uma imagem definida pelo atributo src. O atributo alt é
	//  exibido se o src da imagem estiver ausente.
	KInputTypeImage InputType = "image"

	// KInputTypeMonth
	//
	// English:
	//
	//  A control for entering a month and year, with no time zone.
	//
	// Português:
	//
	//  Um controle para inserir um mês e ano, sem fuso horário.
	KInputTypeMonth InputType = "month"

	// KInputTypeNumber
	//
	// English:
	//
	//  A control for entering a number. Displays a spinner and adds default validation when supported.
	//  Displays a numeric keypad in some devices with dynamic keypads.
	//
	// Português:
	//
	//  Um controle para inserir um número. Exibe um spinner e adiciona validação padrão quando
	//  suportado. Exibe um teclado numérico em alguns dispositivos com teclados dinâmicos.
	KInputTypeNumber InputType = "number"

	// KInputTypePassword
	//
	// English:
	//
	//  A single-line text field whose value is obscured. Will alert user if site is not secure.
	//
	// Português:
	//
	//  Um campo de texto de linha única cujo valor está obscurecido. Alertará o usuário se o site não
	//  for seguro.
	KInputTypePassword InputType = "password"

	// KInputTypeRadio
	//
	// English:
	//
	//  A radio button, allowing a single value to be selected out of multiple choices with the same
	//  name value.
	//
	// Português:
	//
	//  Um botão de opção, permitindo que um único valor seja selecionado entre várias opções com o
	//  mesmo valor de nome.
	KInputTypeRadio InputType = "radio"

	// KInputTypeRange
	//
	// English:
	//
	//  A control for entering a number whose exact value is not important. Displays as a range widget
	//  defaulting to the middle value. Used in conjunction min and max to define the range of
	//  acceptable values.
	//
	// Português:
	//
	//  Um controle para inserir um número cujo valor exato não é importante. Exibe como um widget de
	//  intervalo padronizado para o valor médio. Usado em conjunto min e max para definir a faixa de
	//  valores aceitáveis.
	KInputTypeRange InputType = "range"

	// KInputTypeSearch
	//
	// English:
	//
	//  A single-line text field for entering search strings. Line-breaks are automatically removed
	//  from the input value. May include a delete icon in supporting browsers that can be used to
	//  clear the field. Displays a search icon instead of enter key on some devices with dynamic
	//  keypads.
	//
	// Português:
	//
	//  Um campo de texto de linha única para inserir strings de pesquisa. As quebras de linha são
	//  removidas automaticamente do valor de entrada. Pode incluir um ícone de exclusão em navegadores
	//  de suporte que podem ser usados para limpar o campo. Exibe um ícone de pesquisa em vez da tecla
	//  Enter em alguns dispositivos com teclados dinâmicos.
	KInputTypeSearch InputType = "search"

	// KInputTypeSubmit
	//
	// English:
	//
	//  A button that submits the form.
	//
	// Português:
	//
	//  Um botão que envia o formulário.
	KInputTypeSubmit InputType = "submit"

	// KInputTypeTel
	//
	// English:
	//
	//  A control for entering a telephone number. Displays a telephone keypad in some devices with
	//  dynamic keypads.
	//
	// Português:
	//
	//  Um controle para inserir um número de telefone. Exibe um teclado de telefone em alguns
	//  dispositivos com teclados dinâmicos.
	KInputTypeTel InputType = "tel"

	// KInputTypeText
	//
	// English:
	//
	//  A single-line text field. Line-breaks are automatically removed from the input value. (Default)
	//
	// Português:
	//
	//  Mampo de texto de linha única. As quebras de linha são removidas automaticamente do valor de
	//  entrada. (Padrão)
	KInputTypeText InputType = "text"

	// KInputTypeTime
	//
	// English:
	//
	//  A control for entering a time value with no time zone.
	//
	// Português:
	//
	//  Um controle para inserir um valor de tempo sem fuso horário.
	KInputTypeTime InputType = "time"

	// KInputTypeUrl
	//
	// English:
	//
	//  A field for entering a URL. Looks like a text input, but has validation parameters and relevant
	//  keyboard in supporting browsers and devices with dynamic keyboards.
	//
	// Português:
	//
	//  Um campo para inserir um URL. Parece uma entrada de texto, mas possui parâmetros de validação
	//  e teclado relevante no suporte a navegadores e dispositivos com teclados dinâmicos.
	KInputTypeUrl InputType = "url"

	// KInputTypeWeek
	//
	// English:
	//
	//  A control for entering a date consisting of a week-year number and a week number with no time
	//  zone.
	//
	// Português:
	//
	//  Um controle para inserir uma data que consiste em um número de ano-semana e um número de semana
	//  sem fuso horário.
	KInputTypeWeek InputType = "week"
)

func (InputType) String 

func (e InputType) String() string

type JoinRule 

type JoinRule string
const (
	// KJoinRuleBevel
	//
	// English:
	//
	//  Creates a beveled corner.
	//
	// Português:
	//
	//  Creates a beveled corner.
	KJoinRuleBevel JoinRule = "bevel"

	// KJoinRuleRound
	//
	// English:
	//
	//  A Creates a rounded corner.
	//
	// Português:
	//
	//  A Cria um canto arredondado.
	KJoinRuleRound JoinRule = "round"

	// KJoinRuleMiter
	//
	// English:
	//
	//  (Default) Creates a sharp corner.
	//
	// Português:
	//
	//  (Default) Cria um canto afiado.
	KJoinRuleMiter JoinRule = "miter"
)

func (JoinRule) String 

func (e JoinRule) String() string

type Language 

type Language string
const (
	// KLanguageAbkhazian
	//
	// English:
	//
	//  Abkhazian: 'ab'
	KLanguageAbkhazian Language = "ab"

	// KLanguageAfar
	//
	// English:
	//
	//  Afar: 'aa'
	KLanguageAfar Language = "aa"

	// KLanguageAfrikaans
	//
	// English:
	//
	//  Afrikaans: 'af'
	KLanguageAfrikaans Language = "af"

	// KLanguageAkan
	//
	// English:
	//
	//  Akan: 'ak'
	KLanguageAkan Language = "ak"

	// KLanguageAlbanian
	//
	// English:
	//
	//  Albanian: 'sq'
	KLanguageAlbanian Language = "sq"

	// KLanguageAmharic
	//
	// English:
	//
	//  Amharic: 'am'
	KLanguageAmharic Language = "am"

	// KLanguageArabic
	//
	// English:
	//
	//  Arabic: 'ar'
	KLanguageArabic Language = "ar"

	// KLanguageAragonese
	//
	// English:
	//
	//  Aragonese: 'an'
	KLanguageAragonese Language = "an"

	// KLanguageArmenian
	//
	// English:
	//
	//  Armenian: 'hy'
	KLanguageArmenian Language = "hy"

	// KLanguageAssamese
	//
	// English:
	//
	//  Assamese: 'as'
	KLanguageAssamese Language = "as"

	// KLanguageAvaric
	//
	// English:
	//
	//  Avaric: 'av'
	KLanguageAvaric Language = "av"

	// KLanguageAvestan
	//
	// English:
	//
	//  Avestan: 'ae'
	KLanguageAvestan Language = "ae"

	// KLanguageAymara
	//
	// English:
	//
	//  Aymara: 'ay'
	KLanguageAymara Language = "ay"

	// KLanguageAzerbaijani
	//
	// English:
	//
	//  Azerbaijani: 'az'
	KLanguageAzerbaijani Language = "az"

	// KLanguageBambara
	//
	// English:
	//
	//  Bambara: 'bm'
	KLanguageBambara Language = "bm"

	// KLanguageBashkir
	//
	// English:
	//
	//  Bashkir: 'ba'
	KLanguageBashkir Language = "ba"

	// KLanguageBasque
	//
	// English:
	//
	//  Basque: 'eu'
	KLanguageBasque Language = "eu"

	// KLanguageBelarusian
	//
	// English:
	//
	//  Belarusian: 'be'
	KLanguageBelarusian Language = "be"

	// KLanguageBengaliBangla
	//
	// English:
	//
	//  Bengali (Bangla): 'bn'
	KLanguageBengaliBangla Language = "bn"

	// KLanguageBihari
	//
	// English:
	//
	//  Bihari: 'bh'
	KLanguageBihari Language = "bh"

	// KLanguageBislama
	//
	// English:
	//
	//  Bislama: 'bi'
	KLanguageBislama Language = "bi"

	// KLanguageBosnian
	//
	// English:
	//
	//  Bosnian: 'bs'
	KLanguageBosnian Language = "bs"

	// KLanguageBreton
	//
	// English:
	//
	//  Breton: 'br'
	KLanguageBreton Language = "br"

	// KLanguageBulgarian
	//
	// English:
	//
	//  Bulgarian: 'bg'
	KLanguageBulgarian Language = "bg"

	// KLanguageBurmese
	//
	// English:
	//
	//  Burmese: 'my'
	KLanguageBurmese Language = "my"

	// KLanguageCatalan
	//
	// English:
	//
	//  Catalan: 'ca'
	KLanguageCatalan Language = "ca"

	// KLanguageChamorro
	//
	// English:
	//
	//  Chamorro: 'ch'
	KLanguageChamorro Language = "ch"

	// KLanguageChechen
	//
	// English:
	//
	//  Chechen: 'ce'
	KLanguageChechen Language = "ce"

	// KLanguageChichewa
	//
	// English:
	//
	//  Chichewa: 'ny'
	KLanguageChichewa Language = "ny"

	// KLanguageChewa
	//
	// English:
	//
	//  Chewa: 'ny'
	KLanguageChewa Language = "ny"

	// KLanguageNyanja
	//
	// English:
	//
	//  Nyanja: 'ny'
	KLanguageNyanja Language = "ny"

	// KLanguageChinese
	//
	// English:
	//
	//  Chinese: 'zh'
	KLanguageChinese Language = "zh"

	// KLanguageChineseSimplified
	//
	// English:
	//
	//  Chinese (Simplified): 'zh-Hans'
	KLanguageChineseSimplified Language = "zh-Hans"

	// KLanguageChineseTraditional
	//
	// English:
	//
	//  Chinese (Traditional): 'zh-Hant'
	KLanguageChineseTraditional Language = "zh-Hant"

	// KLanguageChuvash
	//
	// English:
	//
	//  Chuvash: 'cv'
	KLanguageChuvash Language = "cv"

	// KLanguageCornish
	//
	// English:
	//
	//  Cornish: 'kw'
	KLanguageCornish Language = "kw"

	// KLanguageCorsican
	//
	// English:
	//
	//  Corsican: 'co'
	KLanguageCorsican Language = "co"

	// KLanguageCree
	//
	// English:
	//
	//  Cree: 'cr'
	KLanguageCree Language = "cr"

	// KLanguageCroatian
	//
	// English:
	//
	//  Croatian: 'hr'
	KLanguageCroatian Language = "hr"

	// KLanguageCzech
	//
	// English:
	//
	//  Czech: 'cs'
	KLanguageCzech Language = "cs"

	// KLanguageDanish
	//
	// English:
	//
	//  Danish: 'da'
	KLanguageDanish Language = "da"

	// KLanguageDivehi
	//
	// English:
	//
	//  Divehi: 'dv'
	KLanguageDivehi Language = "dv"

	// KLanguageDhivehi
	//
	// English:
	//
	//  Dhivehi: 'dv'
	KLanguageDhivehi Language = "dv"

	// KLanguageMaldivian
	//
	// English:
	//
	//  Maldivian: 'dv'
	KLanguageMaldivian Language = "dv"

	// KLanguageDutch
	//
	// English:
	//
	//  Dutch: 'nl'
	KLanguageDutch Language = "nl"

	// KLanguageDzongkha
	//
	// English:
	//
	//  Dzongkha: 'dz'
	KLanguageDzongkha Language = "dz"

	// KLanguageEnglish
	//
	// English:
	//
	//  English: 'en'
	KLanguageEnglish Language = "en"

	// KLanguageEsperanto
	//
	// English:
	//
	//  Esperanto: 'eo'
	KLanguageEsperanto Language = "eo"

	// KLanguageEstonian
	//
	// English:
	//
	//  Estonian: 'et'
	KLanguageEstonian Language = "et"

	// KLanguageEwe
	//
	// English:
	//
	//  Ewe: 'ee'
	KLanguageEwe Language = "ee"

	// KLanguageFaroese
	//
	// English:
	//
	//  Faroese: 'fo'
	KLanguageFaroese Language = "fo"

	// KLanguageFijian
	//
	// English:
	//
	//  Fijian: 'fj'
	KLanguageFijian Language = "fj"

	// KLanguageFinnish
	//
	// English:
	//
	//  Finnish: 'fi'
	KLanguageFinnish Language = "fi"

	// KLanguageFrench
	//
	// English:
	//
	//  French: 'fr'
	KLanguageFrench Language = "fr"

	// KLanguageFula
	//
	// English:
	//
	//  Fula: 'ff'
	KLanguageFula Language = "ff"

	// KLanguageFulah
	//
	// English:
	//
	//  Fulah: 'ff'
	KLanguageFulah Language = "ff"

	// KLanguagePulaar
	//
	// English:
	//
	//  Pulaar: 'ff'
	KLanguagePulaar Language = "ff"

	// KLanguagePular
	//
	// English:
	//
	//  Pular: 'ff'
	KLanguagePular Language = "ff"

	// KLanguageGalician
	//
	// English:
	//
	//  Galician: 'gl'
	KLanguageGalician Language = "gl"

	// KLanguageGaelicScottish
	//
	// English:
	//
	//  Gaelic (Scottish): 'gd'
	KLanguageGaelicScottish Language = "gd"

	// KLanguageGaelicManx
	//
	// English:
	//
	//  Gaelic (Manx): 'gv'
	KLanguageGaelicManx Language = "gv"

	// KLanguageGeorgian
	//
	// English:
	//
	//  Georgian: 'ka'
	KLanguageGeorgian Language = "ka"

	// KLanguageGerman
	//
	// English:
	//
	//  German: 'de'
	KLanguageGerman Language = "de"

	// KLanguageGreek
	//
	// English:
	//
	//  Greek: 'el'
	KLanguageGreek Language = "el"

	// KLanguageGuarani
	//
	// English:
	//
	//  Guarani: 'gn'
	KLanguageGuarani Language = "gn"

	// KLanguageGujarati
	//
	// English:
	//
	//  Gujarati: 'gu'
	KLanguageGujarati Language = "gu"

	// KLanguageHaitianCreole
	//
	// English:
	//
	//  Haitian Creole: 'ht'
	KLanguageHaitianCreole Language = "ht"

	// KLanguageHausa
	//
	// English:
	//
	//  Hausa: 'ha'
	KLanguageHausa Language = "ha"

	// KLanguageHebrew
	//
	// English:
	//
	//  Hebrew: 'he'
	KLanguageHebrew Language = "he"

	// KLanguageHerero
	//
	// English:
	//
	//  Herero: 'hz'
	KLanguageHerero Language = "hz"

	// KLanguageHindi
	//
	// English:
	//
	//  Hindi: 'hi'
	KLanguageHindi Language = "hi"

	// KLanguageHiriMotu
	//
	// English:
	//
	//  Hiri Motu: 'ho'
	KLanguageHiriMotu Language = "ho"

	// KLanguageHungarian
	//
	// English:
	//
	//  Hungarian: 'hu'
	KLanguageHungarian Language = "hu"

	// KLanguageIcelandic
	//
	// English:
	//
	//  Icelandic: 'is'
	KLanguageIcelandic Language = "is"

	// KLanguageIdo
	//
	// English:
	//
	//  Ido: 'io'
	KLanguageIdo Language = "io"

	// KLanguageIgbo
	//
	// English:
	//
	//  Igbo: 'ig'
	KLanguageIgbo Language = "ig"

	// KLanguageIndonesian
	//
	// English:
	//
	//  Indonesian: 'id, in'
	KLanguageIndonesian Language = "id, in"

	// KLanguageInterlingua
	//
	// English:
	//
	//  Interlingua: 'ia'
	KLanguageInterlingua Language = "ia"

	// KLanguageInterlingue
	//
	// English:
	//
	//  Interlingue: 'ie'
	KLanguageInterlingue Language = "ie"

	// KLanguageInuktitut
	//
	// English:
	//
	//  Inuktitut: 'iu'
	KLanguageInuktitut Language = "iu"

	// KLanguageInupiak
	//
	// English:
	//
	//  Inupiak: 'ik'
	KLanguageInupiak Language = "ik"

	// KLanguageIrish
	//
	// English:
	//
	//  Irish: 'ga'
	KLanguageIrish Language = "ga"

	// KLanguageItalian
	//
	// English:
	//
	//  Italian: 'it'
	KLanguageItalian Language = "it"

	// KLanguageJapanese
	//
	// English:
	//
	//  Japanese: 'ja'
	KLanguageJapanese Language = "ja"

	// KLanguageJavanese
	//
	// English:
	//
	//  Javanese: 'jv'
	KLanguageJavanese Language = "jv"

	// KLanguageKalaallisut
	//
	// English:
	//
	//  Kalaallisut: 'kl'
	KLanguageKalaallisut Language = "kl"

	// KLanguageGreenlandic
	//
	// English:
	//
	//  Greenlandic: 'kl'
	KLanguageGreenlandic Language = "kl"

	// KLanguageKannada
	//
	// English:
	//
	//  Kannada: 'kn'
	KLanguageKannada Language = "kn"

	// KLanguageKanuri
	//
	// English:
	//
	//  Kanuri: 'kr'
	KLanguageKanuri Language = "kr"

	// KLanguageKashmiri
	//
	// English:
	//
	//  Kashmiri: 'ks'
	KLanguageKashmiri Language = "ks"

	// KLanguageKazakh
	//
	// English:
	//
	//  Kazakh: 'kk'
	KLanguageKazakh Language = "kk"

	// KLanguageKhmer
	//
	// English:
	//
	//  Khmer: 'km'
	KLanguageKhmer Language = "km"

	// KLanguageKikuyu
	//
	// English:
	//
	//  Kikuyu: 'ki'
	KLanguageKikuyu Language = "ki"

	// KLanguageKinyarwandaRwanda
	//
	// English:
	//
	//  Kinyarwanda (Rwanda): 'rw'
	KLanguageKinyarwandaRwanda Language = "rw"

	// KLanguageKirundi
	//
	// English:
	//
	//  Kirundi: 'rn'
	KLanguageKirundi Language = "rn"

	// KLanguageKyrgyz
	//
	// English:
	//
	//  Kyrgyz: 'ky'
	KLanguageKyrgyz Language = "ky"

	// KLanguageKomi
	//
	// English:
	//
	//  Komi: 'kv'
	KLanguageKomi Language = "kv"

	// KLanguageKongo
	//
	// English:
	//
	//  Kongo: 'kg'
	KLanguageKongo Language = "kg"

	// KLanguageKorean
	//
	// English:
	//
	//  Korean: 'ko'
	KLanguageKorean Language = "ko"

	// KLanguageKurdish
	//
	// English:
	//
	//  Kurdish: 'ku'
	KLanguageKurdish Language = "ku"

	// KLanguageKwanyama
	//
	// English:
	//
	//  Kwanyama: 'kj'
	KLanguageKwanyama Language = "kj"

	// KLanguageLao
	//
	// English:
	//
	//  Lao: 'lo'
	KLanguageLao Language = "lo"

	// KLanguageLatin
	//
	// English:
	//
	//  Latin: 'la'
	KLanguageLatin Language = "la"

	// KLanguageLatvianLettish
	//
	// English:
	//
	//  Latvian (Lettish): 'lv'
	KLanguageLatvianLettish Language = "lv"

	// KLanguageLimburgishLimburger
	//
	// English:
	//
	//  Limburgish ( Limburger): 'li'
	KLanguageLimburgishLimburger Language = "li"

	// KLanguageLingala
	//
	// English:
	//
	//  Lingala: 'ln'
	KLanguageLingala Language = "ln"

	// KLanguageLithuanian
	//
	// English:
	//
	//  Lithuanian: 'lt'
	KLanguageLithuanian Language = "lt"

	// KLanguageLugaKatanga
	//
	// English:
	//
	//  Luga-Katanga: 'lu'
	KLanguageLugaKatanga Language = "lu"

	// KLanguageLuganda
	//
	// English:
	//
	//  Luganda: 'lg'
	KLanguageLuganda Language = "lg"

	// KLanguageGanda
	//
	// English:
	//
	//  Ganda: 'lg'
	KLanguageGanda Language = "lg"

	// KLanguageLuxembourgish
	//
	// English:
	//
	//  Luxembourgish: 'lb'
	KLanguageLuxembourgish Language = "lb"

	// KLanguageManx
	//
	// English:
	//
	//  Manx: 'gv'
	KLanguageManx Language = "gv"

	// KLanguageMacedonian
	//
	// English:
	//
	//  Macedonian: 'mk'
	KLanguageMacedonian Language = "mk"

	// KLanguageMalagasy
	//
	// English:
	//
	//  Malagasy: 'mg'
	KLanguageMalagasy Language = "mg"

	// KLanguageMalay
	//
	// English:
	//
	//  Malay: 'ms'
	KLanguageMalay Language = "ms"

	// KLanguageMalayalam
	//
	// English:
	//
	//  Malayalam: 'ml'
	KLanguageMalayalam Language = "ml"

	// KLanguageMaltese
	//
	// English:
	//
	//  Maltese: 'mt'
	KLanguageMaltese Language = "mt"

	// KLanguageMaori
	//
	// English:
	//
	//  Maori: 'mi'
	KLanguageMaori Language = "mi"

	// KLanguageMarathi
	//
	// English:
	//
	//  Marathi: 'mr'
	KLanguageMarathi Language = "mr"

	// KLanguageMarshallese
	//
	// English:
	//
	//  Marshallese: 'mh'
	KLanguageMarshallese Language = "mh"

	// KLanguageMoldavian
	//
	// English:
	//
	//  Moldavian: 'mo'
	KLanguageMoldavian Language = "mo"

	// KLanguageMongolian
	//
	// English:
	//
	//  Mongolian: 'mn'
	KLanguageMongolian Language = "mn"

	// KLanguageNauru
	//
	// English:
	//
	//  Nauru: 'na'
	KLanguageNauru Language = "na"

	// KLanguageNavajo
	//
	// English:
	//
	//  Navajo: 'nv'
	KLanguageNavajo Language = "nv"

	// KLanguageNdonga
	//
	// English:
	//
	//  Ndonga: 'ng'
	KLanguageNdonga Language = "ng"

	// KLanguageNorthernNdebele
	//
	// English:
	//
	//  Northern Ndebele: 'nd'
	KLanguageNorthernNdebele Language = "nd"

	// KLanguageNepali
	//
	// English:
	//
	//  Nepali: 'ne'
	KLanguageNepali Language = "ne"

	// KLanguageNorwegian
	//
	// English:
	//
	//  Norwegian: 'no'
	KLanguageNorwegian Language = "no"

	// KLanguageNorwegianBokmål
	//
	// English:
	//
	//  Norwegian bokmål: 'nb'
	KLanguageNorwegianBokmål Language = "nb"

	// KLanguageNorwegianNynorsk
	//
	// English:
	//
	//  Norwegian nynorsk: 'nn'
	KLanguageNorwegianNynorsk Language = "nn"

	// KLanguageNuosu
	//
	// English:
	//
	//  Nuosu: 'ii'
	KLanguageNuosu Language = "ii"

	// KLanguageOccitan
	//
	// English:
	//
	//  Occitan: 'oc'
	KLanguageOccitan Language = "oc"

	// KLanguageOjibwe
	//
	// English:
	//
	//  Ojibwe: 'oj'
	KLanguageOjibwe Language = "oj"

	// KLanguageOldChurchSlavonic
	//
	// English:
	//
	//  Old Church Slavonic: 'cu'
	KLanguageOldChurchSlavonic Language = "cu"

	// KLanguageOldBulgarian
	//
	// English:
	//
	//  Old Bulgarian: 'cu'
	KLanguageOldBulgarian Language = "cu"

	// KLanguageOriya
	//
	// English:
	//
	//  Oriya: 'or'
	KLanguageOriya Language = "or"

	// KLanguageOromoAfaanOromo
	//
	// English:
	//
	//  Oromo (Afaan Oromo): 'om'
	KLanguageOromoAfaanOromo Language = "om"

	// KLanguageOssetian
	//
	// English:
	//
	//  Ossetian: 'os'
	KLanguageOssetian Language = "os"

	// KLanguagePali
	//
	// English:
	//
	//  Pāli: 'pi'
	KLanguagePali Language = "pi"

	// KLanguagePashto
	//
	// English:
	//
	//  Pashto: 'ps'
	KLanguagePashto Language = "ps"

	// KLanguagePushto
	//
	// English:
	//
	//  Pushto: 'ps'
	KLanguagePushto Language = "ps"

	// KLanguagePersianFarsi
	//
	// English:
	//
	//  Persian (Farsi): 'fa'
	KLanguagePersianFarsi Language = "fa"

	// KLanguagePolish
	//
	// English:
	//
	//  Polish: 'pl'
	KLanguagePolish Language = "pl"

	// KLanguagePortuguese
	//
	// English:
	//
	//  Portuguese: 'pt'
	KLanguagePortuguese Language = "pt"

	// KLanguagePunjabiEastern
	//
	// English:
	//
	//  Punjabi (Eastern): 'pa'
	KLanguagePunjabiEastern Language = "pa"

	// KLanguageQuechua
	//
	// English:
	//
	//  Quechua: 'qu'
	KLanguageQuechua Language = "qu"

	// KLanguageRomansh
	//
	// English:
	//
	//  Romansh: 'rm'
	KLanguageRomansh Language = "rm"

	// KLanguageRomanian
	//
	// English:
	//
	//  Romanian: 'ro'
	KLanguageRomanian Language = "ro"

	// KLanguageRussian
	//
	// English:
	//
	//  Russian: 'ru'
	KLanguageRussian Language = "ru"

	// KLanguageSami
	//
	// English:
	//
	//  Sami: 'se'
	KLanguageSami Language = "se"

	// KLanguageSamoan
	//
	// English:
	//
	//  Samoan: 'sm'
	KLanguageSamoan Language = "sm"

	// KLanguageSango
	//
	// English:
	//
	//  Sango: 'sg'
	KLanguageSango Language = "sg"

	// KLanguageSanskrit
	//
	// English:
	//
	//  Sanskrit: 'sa'
	KLanguageSanskrit Language = "sa"

	// KLanguageSerbian
	//
	// English:
	//
	//  Serbian: 'sr'
	KLanguageSerbian Language = "sr"

	// KLanguageSerboCroatian
	//
	// English:
	//
	//  Serbo-Croatian: 'sh'
	KLanguageSerboCroatian Language = "sh"

	// KLanguageSesotho
	//
	// English:
	//
	//  Sesotho: 'st'
	KLanguageSesotho Language = "st"

	// KLanguageSetswana
	//
	// English:
	//
	//  Setswana: 'tn'
	KLanguageSetswana Language = "tn"

	// KLanguageShona
	//
	// English:
	//
	//  Shona: 'sn'
	KLanguageShona Language = "sn"

	// KLanguageSichuanYi
	//
	// English:
	//
	//  Sichuan Yi: 'ii'
	KLanguageSichuanYi Language = "ii"

	// KLanguageSindhi
	//
	// English:
	//
	//  Sindhi: 'sd'
	KLanguageSindhi Language = "sd"

	// KLanguageSinhalese
	//
	// English:
	//
	//  Sinhalese: 'si'
	KLanguageSinhalese Language = "si"

	// KLanguageSiswati
	//
	// English:
	//
	//  Siswati: 'ss'
	KLanguageSiswati Language = "ss"

	// KLanguageSlovak
	//
	// English:
	//
	//  Slovak: 'sk'
	KLanguageSlovak Language = "sk"

	// KLanguageSlovenian
	//
	// English:
	//
	//  Slovenian: 'sl'
	KLanguageSlovenian Language = "sl"

	// KLanguageSomali
	//
	// English:
	//
	//  Somali: 'so'
	KLanguageSomali Language = "so"

	// KLanguageSouthernNdebele
	//
	// English:
	//
	//  Southern Ndebele: 'nr'
	KLanguageSouthernNdebele Language = "nr"

	// KLanguageSpanish
	//
	// English:
	//
	//  Spanish: 'es'
	KLanguageSpanish Language = "es"

	// KLanguageSundanese
	//
	// English:
	//
	//  Sundanese: 'su'
	KLanguageSundanese Language = "su"

	// KLanguageSwahiliKiswahili
	//
	// English:
	//
	//  Swahili (Kiswahili): 'sw'
	KLanguageSwahiliKiswahili Language = "sw"

	// KLanguageSwati
	//
	// English:
	//
	//  Swati: 'ss'
	KLanguageSwati Language = "ss"

	// KLanguageSwedish
	//
	// English:
	//
	//  Swedish: 'sv'
	KLanguageSwedish Language = "sv"

	// KLanguageTagalog
	//
	// English:
	//
	//  Tagalog: 'tl'
	KLanguageTagalog Language = "tl"

	// KLanguageTahitian
	//
	// English:
	//
	//  Tahitian: 'ty'
	KLanguageTahitian Language = "ty"

	// KLanguageTajik
	//
	// English:
	//
	//  Tajik: 'tg'
	KLanguageTajik Language = "tg"

	// KLanguageTamil
	//
	// English:
	//
	//  Tamil: 'ta'
	KLanguageTamil Language = "ta"

	// KLanguageTatar
	//
	// English:
	//
	//  Tatar: 'tt'
	KLanguageTatar Language = "tt"

	// KLanguageTelugu
	//
	// English:
	//
	//  Telugu: 'te'
	KLanguageTelugu Language = "te"

	// KLanguageThai
	//
	// English:
	//
	//  Thai: 'th'
	KLanguageThai Language = "th"

	// KLanguageTibetan
	//
	// English:
	//
	//  Tibetan: 'bo'
	KLanguageTibetan Language = "bo"

	// KLanguageTigrinya
	//
	// English:
	//
	//  Tigrinya: 'ti'
	KLanguageTigrinya Language = "ti"

	// KLanguageTonga
	//
	// English:
	//
	//  Tonga: 'to'
	KLanguageTonga Language = "to"

	// KLanguageTsonga
	//
	// English:
	//
	//  Tsonga: 'ts'
	KLanguageTsonga Language = "ts"

	// KLanguageTurkish
	//
	// English:
	//
	//  Turkish: 'tr'
	KLanguageTurkish Language = "tr"

	// KLanguageTurkmen
	//
	// English:
	//
	//  Turkmen: 'tk'
	KLanguageTurkmen Language = "tk"

	// KLanguageTwi
	//
	// English:
	//
	//  Twi: 'tw'
	KLanguageTwi Language = "tw"

	// KLanguageUyghur
	//
	// English:
	//
	//  Uyghur: 'ug'
	KLanguageUyghur Language = "ug"

	// KLanguageUkrainian
	//
	// English:
	//
	//  Ukrainian: 'uk'
	KLanguageUkrainian Language = "uk"

	// KLanguageUrdu
	//
	// English:
	//
	//  Urdu: 'ur'
	KLanguageUrdu Language = "ur"

	// KLanguageUzbek
	//
	// English:
	//
	//  Uzbek: 'uz'
	KLanguageUzbek Language = "uz"

	// KLanguageVenda
	//
	// English:
	//
	//  Venda: 've'
	KLanguageVenda Language = "ve"

	// KLanguageVietnamese
	//
	// English:
	//
	//  Vietnamese: 'vi'
	KLanguageVietnamese Language = "vi"

	// KLanguageVolapük
	//
	// English:
	//
	//  Volapük: 'vo'
	KLanguageVolapük Language = "vo"

	// KLanguageWallon
	//
	// English:
	//
	//  Wallon: 'wa'
	KLanguageWallon Language = "wa"

	// KLanguageWelsh
	//
	// English:
	//
	//  Welsh: 'cy'
	KLanguageWelsh Language = "cy"

	// KLanguageWolof
	//
	// English:
	//
	//  Wolof: 'wo'
	KLanguageWolof Language = "wo"

	// KLanguageWesternFrisian
	//
	// English:
	//
	//  Western Frisian: 'fy'
	KLanguageWesternFrisian Language = "fy"

	// KLanguageXhosa
	//
	// English:
	//
	//  Xhosa: 'xh'
	KLanguageXhosa Language = "xh"

	// KLanguageYiddish
	//
	// English:
	//
	//  Yiddish: 'yi, ji'
	KLanguageYiddish Language = "yi, ji"

	// KLanguageYoruba
	//
	// English:
	//
	//  Yoruba: 'yo'
	KLanguageYoruba Language = "yo"

	// KLanguageZhuang
	//
	// English:
	//
	//  Zhuang: 'za'
	KLanguageZhuang Language = "za"

	// KLanguageChuang
	//
	// English:
	//
	//  Chuang: 'za'
	KLanguageChuang Language = "za"

	// KLanguageZulu
	//
	// English:
	//
	//  Zulu: 'zu'
	KLanguageZulu Language = "zu"
)

func (Language) String 

func (e Language) String() string

type Mime 

type Mime string

Mime

Source: 

https://www.iana.org/assignments/media-types/media-types.xhtml#audio

English: 

A MIME type (now properly called "media type", but also sometimes "content type") is a string sent
along with a file indicating the type of the file (describing the content format, for example, a
sound file might be labeled audio/ogg, or an image file image/png).

It serves the same purpose as filename extensions traditionally do on Windows. The name originates from the MIME standard originally used in E-Mail.

Português: 

Um tipo MIME (agora chamado corretamente de "tipo de mídia", mas também às vezes "tipo de
conteúdo") é uma string enviada junto com um arquivo que indica o tipo do arquivo (descrevendo o
formato do conteúdo, por exemplo, um arquivo de som pode ser rotulado como audio/ogg , ou um
arquivo de imagem image/png).

Ele serve ao mesmo propósito que as extensões de nome de arquivo tradicionalmente fazem no Windows. O nome se origina do padrão MIME originalmente usado em E-Mail. 

const (
	// KMimeApplication1dInterleavedParityfec
	//
	// English:
	//
	//  Application type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Aplicação tipo '1d-interleaved-parityfec'
	KMimeApplication1dInterleavedParityfec Mime = "application/1d-interleaved-parityfec"

	// KMimeApplication3gpdashQoeReportXml
	//
	// English:
	//
	//  Application type '3gpdash-qoe-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo '3gpdash-qoe-report+xml'
	KMimeApplication3gpdashQoeReportXml Mime = "application/3gpdash-qoe-report+xml"

	// KMimeApplication3gppHalJson
	//
	// English:
	//
	//  Application type '3gppHal+json'
	//
	// Português:
	//
	//  Aplicação tipo '3gppHal+json'
	KMimeApplication3gppHalJson Mime = "application/3gppHal+json"

	// KMimeApplication3gppHalFormsJson
	//
	// English:
	//
	//  Application type '3gppHalForms+json'
	//
	// Português:
	//
	//  Aplicação tipo '3gppHalForms+json'
	KMimeApplication3gppHalFormsJson Mime = "application/3gppHalForms+json"

	// KMimeApplication3gppImsXml
	//
	// English:
	//
	//  Application type '3gpp-ims+xml'
	//
	// Português:
	//
	//  Aplicação tipo '3gpp-ims+xml'
	KMimeApplication3gppImsXml Mime = "application/3gpp-ims+xml"

	// KMimeApplicationA2L
	//
	// English:
	//
	//  Application type 'A2L'
	//
	// Português:
	//
	//  Aplicação tipo 'A2L'
	KMimeApplicationA2L Mime = "application/A2L"

	// KMimeApplicationAceCbor
	//
	// English:
	//
	//  Application type 'ace+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'ace+cbor'
	KMimeApplicationAceCbor Mime = "application/ace+cbor"

	// KMimeApplicationAceJson
	//
	// English:
	//
	//  Application type 'ace+json'
	//
	// Português:
	//
	//  Aplicação tipo 'ace+json'
	KMimeApplicationAceJson Mime = "application/ace+json"

	// KMimeApplicationActivemessage
	//
	// English:
	//
	//  Application type 'activemessage'
	//
	// Português:
	//
	//  Aplicação tipo 'activemessage'
	KMimeApplicationActivemessage Mime = "application/activemessage"

	// KMimeApplicationActivityJson
	//
	// English:
	//
	//  Application type 'activity+json'
	//
	// Português:
	//
	//  Aplicação tipo 'activity+json'
	KMimeApplicationActivityJson Mime = "application/activity+json"

	// KMimeApplicationAifCbor
	//
	// English:
	//
	//  Application type 'aif+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'aif+cbor'
	KMimeApplicationAifCbor Mime = "application/aif+cbor"

	// KMimeApplicationAifJson
	//
	// English:
	//
	//  Application type 'aif+json'
	//
	// Português:
	//
	//  Aplicação tipo 'aif+json'
	KMimeApplicationAifJson Mime = "application/aif+json"

	// KMimeApplicationAltoCdniJson
	//
	// English:
	//
	//  Application type 'alto-cdni+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-cdni+json'
	KMimeApplicationAltoCdniJson Mime = "application/alto-cdni+json"

	// KMimeApplicationAltoCdnifilterJson
	//
	// English:
	//
	//  Application type 'alto-cdnifilter+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-cdnifilter+json'
	KMimeApplicationAltoCdnifilterJson Mime = "application/alto-cdnifilter+json"

	// KMimeApplicationAltoCostmapJson
	//
	// English:
	//
	//  Application type 'alto-costmap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-costmap+json'
	KMimeApplicationAltoCostmapJson Mime = "application/alto-costmap+json"

	// KMimeApplicationAltoCostmapfilterJson
	//
	// English:
	//
	//  Application type 'alto-costmapfilter+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-costmapfilter+json'
	KMimeApplicationAltoCostmapfilterJson Mime = "application/alto-costmapfilter+json"

	// KMimeApplicationAltoDirectoryJson
	//
	// English:
	//
	//  Application type 'alto-directory+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-directory+json'
	KMimeApplicationAltoDirectoryJson Mime = "application/alto-directory+json"

	// KMimeApplicationAltoEndpointpropJson
	//
	// English:
	//
	//  Application type 'alto-endpointprop+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointprop+json'
	KMimeApplicationAltoEndpointpropJson Mime = "application/alto-endpointprop+json"

	// KMimeApplicationAltoEndpointpropparamsJson
	//
	// English:
	//
	//  Application type 'alto-endpointpropparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointpropparams+json'
	KMimeApplicationAltoEndpointpropparamsJson Mime = "application/alto-endpointpropparams+json"

	// KMimeApplicationAltoEndpointcostJson
	//
	// English:
	//
	//  Application type 'alto-endpointcost+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointcost+json'
	KMimeApplicationAltoEndpointcostJson Mime = "application/alto-endpointcost+json"

	// KMimeApplicationAltoEndpointcostparamsJson
	//
	// English:
	//
	//  Application type 'alto-endpointcostparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-endpointcostparams+json'
	KMimeApplicationAltoEndpointcostparamsJson Mime = "application/alto-endpointcostparams+json"

	// KMimeApplicationAltoErrorJson
	//
	// English:
	//
	//  Application type 'alto-error+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-error+json'
	KMimeApplicationAltoErrorJson Mime = "application/alto-error+json"

	// KMimeApplicationAltoNetworkmapfilterJson
	//
	// English:
	//
	//  Application type 'alto-networkmapfilter+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-networkmapfilter+json'
	KMimeApplicationAltoNetworkmapfilterJson Mime = "application/alto-networkmapfilter+json"

	// KMimeApplicationAltoNetworkmapJson
	//
	// English:
	//
	//  Application type 'alto-networkmap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-networkmap+json'
	KMimeApplicationAltoNetworkmapJson Mime = "application/alto-networkmap+json"

	// KMimeApplicationAltoPropmapJson
	//
	// English:
	//
	//  Application type 'alto-propmap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-propmap+json'
	KMimeApplicationAltoPropmapJson Mime = "application/alto-propmap+json"

	// KMimeApplicationAltoPropmapparamsJson
	//
	// English:
	//
	//  Application type 'alto-propmapparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-propmapparams+json'
	KMimeApplicationAltoPropmapparamsJson Mime = "application/alto-propmapparams+json"

	// KMimeApplicationAltoUpdatestreamcontrolJson
	//
	// English:
	//
	//  Application type 'alto-updatestreamcontrol+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-updatestreamcontrol+json'
	KMimeApplicationAltoUpdatestreamcontrolJson Mime = "application/alto-updatestreamcontrol+json"

	// KMimeApplicationAltoUpdatestreamparamsJson
	//
	// English:
	//
	//  Application type 'alto-updatestreamparams+json'
	//
	// Português:
	//
	//  Aplicação tipo 'alto-updatestreamparams+json'
	KMimeApplicationAltoUpdatestreamparamsJson Mime = "application/alto-updatestreamparams+json"

	// KMimeApplicationAML
	//
	// English:
	//
	//  Application type 'AML'
	//
	// Português:
	//
	//  Aplicação tipo 'AML'
	KMimeApplicationAML Mime = "application/AML"

	// KMimeApplicationAndrewInset
	//
	// English:
	//
	//  Application type 'andrew-inset'
	//
	// Português:
	//
	//  Aplicação tipo 'andrew-inset'
	KMimeApplicationAndrewInset Mime = "application/andrew-inset"

	// KMimeApplicationApplefile
	//
	// English:
	//
	//  Application type 'applefile'
	//
	// Português:
	//
	//  Aplicação tipo 'applefile'
	KMimeApplicationApplefile Mime = "application/applefile"

	// KMimeApplicationAtJwt
	//
	// English:
	//
	//  Application type 'at+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'at+jwt'
	KMimeApplicationAtJwt Mime = "application/at+jwt"

	// KMimeApplicationATF
	//
	// English:
	//
	//  Application type 'ATF'
	//
	// Português:
	//
	//  Aplicação tipo 'ATF'
	KMimeApplicationATF Mime = "application/ATF"

	// KMimeApplicationATFX
	//
	// English:
	//
	//  Application type 'ATFX'
	//
	// Português:
	//
	//  Aplicação tipo 'ATFX'
	KMimeApplicationATFX Mime = "application/ATFX"

	// KMimeApplicationAtomXml
	//
	// English:
	//
	//  Application type 'atom+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atom+xml'
	KMimeApplicationAtomXml Mime = "application/atom+xml"

	// KMimeApplicationAtomcatXml
	//
	// English:
	//
	//  Application type 'atomcat+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atomcat+xml'
	KMimeApplicationAtomcatXml Mime = "application/atomcat+xml"

	// KMimeApplicationAtomdeletedXml
	//
	// English:
	//
	//  Application type 'atomdeleted+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atomdeleted+xml'
	KMimeApplicationAtomdeletedXml Mime = "application/atomdeleted+xml"

	// KMimeApplicationAtomicmail
	//
	// English:
	//
	//  Application type 'atomicmail'
	//
	// Português:
	//
	//  Aplicação tipo 'atomicmail'
	KMimeApplicationAtomicmail Mime = "application/atomicmail"

	// KMimeApplicationAtomsvcXml
	//
	// English:
	//
	//  Application type 'atomsvc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atomsvc+xml'
	KMimeApplicationAtomsvcXml Mime = "application/atomsvc+xml"

	// KMimeApplicationAtscDwdXml
	//
	// English:
	//
	//  Application type 'atsc-dwd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-dwd+xml'
	KMimeApplicationAtscDwdXml Mime = "application/atsc-dwd+xml"

	// KMimeApplicationAtscDynamicEventMessage
	//
	// English:
	//
	//  Application type 'atsc-dynamic-event-message'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-dynamic-event-message'
	KMimeApplicationAtscDynamicEventMessage Mime = "application/atsc-dynamic-event-message"

	// KMimeApplicationAtscHeldXml
	//
	// English:
	//
	//  Application type 'atsc-held+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-held+xml'
	KMimeApplicationAtscHeldXml Mime = "application/atsc-held+xml"

	// KMimeApplicationAtscRdtJson
	//
	// English:
	//
	//  Application type 'atsc-rdt+json'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-rdt+json'
	KMimeApplicationAtscRdtJson Mime = "application/atsc-rdt+json"

	// KMimeApplicationAtscRsatXml
	//
	// English:
	//
	//  Application type 'atsc-rsat+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'atsc-rsat+xml'
	KMimeApplicationAtscRsatXml Mime = "application/atsc-rsat+xml"

	// KMimeApplicationATXML
	//
	// English:
	//
	//  Application type 'ATXML'
	//
	// Português:
	//
	//  Aplicação tipo 'ATXML'
	KMimeApplicationATXML Mime = "application/ATXML"

	// KMimeApplicationAuthPolicyXml
	//
	// English:
	//
	//  Application type 'auth-policy+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'auth-policy+xml'
	KMimeApplicationAuthPolicyXml Mime = "application/auth-policy+xml"

	// KMimeApplicationBacnetXddZip
	//
	// English:
	//
	//  Application type 'bacnet-xdd+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'bacnet-xdd+zip'
	KMimeApplicationBacnetXddZip Mime = "application/bacnet-xdd+zip"

	// KMimeApplicationBatchSMTP
	//
	// English:
	//
	//  Application type 'batch-SMTP'
	//
	// Português:
	//
	//  Aplicação tipo 'batch-SMTP'
	KMimeApplicationBatchSMTP Mime = "application/batch-SMTP"

	// KMimeApplicationBeepXml
	//
	// English:
	//
	//  Application type 'beep+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'beep+xml'
	KMimeApplicationBeepXml Mime = "application/beep+xml"

	// KMimeApplicationCalendarJson
	//
	// English:
	//
	//  Application type 'calendar+json'
	//
	// Português:
	//
	//  Aplicação tipo 'calendar+json'
	KMimeApplicationCalendarJson Mime = "application/calendar+json"

	// KMimeApplicationCalendarXml
	//
	// English:
	//
	//  Application type 'calendar+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'calendar+xml'
	KMimeApplicationCalendarXml Mime = "application/calendar+xml"

	// KMimeApplicationCallCompletion
	//
	// English:
	//
	//  Application type 'call-completion'
	//
	// Português:
	//
	//  Aplicação tipo 'call-completion'
	KMimeApplicationCallCompletion Mime = "application/call-completion"

	// KMimeApplicationCALS1840
	//
	// English:
	//
	//  Application type 'CALS-1840'
	//
	// Português:
	//
	//  Aplicação tipo 'CALS-1840'
	KMimeApplicationCALS1840 Mime = "application/CALS-1840"

	// KMimeApplicationCaptiveJson
	//
	// English:
	//
	//  Application type 'captive+json'
	//
	// Português:
	//
	//  Aplicação tipo 'captive+json'
	KMimeApplicationCaptiveJson Mime = "application/captive+json"

	// KMimeApplicationCbor
	//
	// English:
	//
	//  Application type 'cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'cbor'
	KMimeApplicationCbor Mime = "application/cbor"

	// KMimeApplicationCborSeq
	//
	// English:
	//
	//  Application type 'cbor-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'cbor-seq'
	KMimeApplicationCborSeq Mime = "application/cbor-seq"

	// KMimeApplicationCccex
	//
	// English:
	//
	//  Application type 'cccex'
	//
	// Português:
	//
	//  Aplicação tipo 'cccex'
	KMimeApplicationCccex Mime = "application/cccex"

	// KMimeApplicationCcmpXml
	//
	// English:
	//
	//  Application type 'ccmp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ccmp+xml'
	KMimeApplicationCcmpXml Mime = "application/ccmp+xml"

	// KMimeApplicationCcxmlXml
	//
	// English:
	//
	//  Application type 'ccxml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ccxml+xml'
	KMimeApplicationCcxmlXml Mime = "application/ccxml+xml"

	// KMimeApplicationCdaXml
	//
	// English:
	//
	//  Application type 'cda+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cda+xml'
	KMimeApplicationCdaXml Mime = "application/cda+xml"

	// KMimeApplicationCDFXXML
	//
	// English:
	//
	//  Application type 'CDFX+XML'
	//
	// Português:
	//
	//  Aplicação tipo 'CDFX+XML'
	KMimeApplicationCDFXXML Mime = "application/CDFX+XML"

	// KMimeApplicationCdmiCapability
	//
	// English:
	//
	//  Application type 'cdmi-capability'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-capability'
	KMimeApplicationCdmiCapability Mime = "application/cdmi-capability"

	// KMimeApplicationCdmiContainer
	//
	// English:
	//
	//  Application type 'cdmi-container'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-container'
	KMimeApplicationCdmiContainer Mime = "application/cdmi-container"

	// KMimeApplicationCdmiDomain
	//
	// English:
	//
	//  Application type 'cdmi-domain'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-domain'
	KMimeApplicationCdmiDomain Mime = "application/cdmi-domain"

	// KMimeApplicationCdmiObject
	//
	// English:
	//
	//  Application type 'cdmi-object'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-object'
	KMimeApplicationCdmiObject Mime = "application/cdmi-object"

	// KMimeApplicationCdmiQueue
	//
	// English:
	//
	//  Application type 'cdmi-queue'
	//
	// Português:
	//
	//  Aplicação tipo 'cdmi-queue'
	KMimeApplicationCdmiQueue Mime = "application/cdmi-queue"

	// KMimeApplicationCdni
	//
	// English:
	//
	//  Application type 'cdni'
	//
	// Português:
	//
	//  Aplicação tipo 'cdni'
	KMimeApplicationCdni Mime = "application/cdni"

	// KMimeApplicationCEA
	//
	// English:
	//
	//  Application type 'CEA'
	//
	// Português:
	//
	//  Aplicação tipo 'CEA'
	KMimeApplicationCEA Mime = "application/CEA"

	// KMimeApplicationCea2018Xml
	//
	// English:
	//
	//  Application type 'cea-2018+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cea-2018+xml'
	KMimeApplicationCea2018Xml Mime = "application/cea-2018+xml"

	// KMimeApplicationCellmlXml
	//
	// English:
	//
	//  Application type 'cellml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cellml+xml'
	KMimeApplicationCellmlXml Mime = "application/cellml+xml"

	// KMimeApplicationCfw
	//
	// English:
	//
	//  Application type 'cfw'
	//
	// Português:
	//
	//  Aplicação tipo 'cfw'
	KMimeApplicationCfw Mime = "application/cfw"

	// KMimeApplicationCityJson
	//
	// English:
	//
	//  Application type 'city+json'
	//
	// Português:
	//
	//  Aplicação tipo 'city+json'
	KMimeApplicationCityJson Mime = "application/city+json"

	// KMimeApplicationClr
	//
	// English:
	//
	//  Application type 'clr'
	//
	// Português:
	//
	//  Aplicação tipo 'clr'
	KMimeApplicationClr Mime = "application/clr"

	// KMimeApplicationClueInfoXml
	//
	// English:
	//
	//  Application type 'clue_info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'clue_info+xml'
	KMimeApplicationClueInfoXml Mime = "application/clue_info+xml"

	// KMimeApplicationClueXml
	//
	// English:
	//
	//  Application type 'clue+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'clue+xml'
	KMimeApplicationClueXml Mime = "application/clue+xml"

	// KMimeApplicationCms
	//
	// English:
	//
	//  Application type 'cms'
	//
	// Português:
	//
	//  Aplicação tipo 'cms'
	KMimeApplicationCms Mime = "application/cms"

	// KMimeApplicationCnrpXml
	//
	// English:
	//
	//  Application type 'cnrp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cnrp+xml'
	KMimeApplicationCnrpXml Mime = "application/cnrp+xml"

	// KMimeApplicationCoapGroupJson
	//
	// English:
	//
	//  Application type 'coap-group+json'
	//
	// Português:
	//
	//  Aplicação tipo 'coap-group+json'
	KMimeApplicationCoapGroupJson Mime = "application/coap-group+json"

	// KMimeApplicationCoapPayload
	//
	// English:
	//
	//  Application type 'coap-payload'
	//
	// Português:
	//
	//  Aplicação tipo 'coap-payload'
	KMimeApplicationCoapPayload Mime = "application/coap-payload"

	// KMimeApplicationCommonground
	//
	// English:
	//
	//  Application type 'commonground'
	//
	// Português:
	//
	//  Aplicação tipo 'commonground'
	KMimeApplicationCommonground Mime = "application/commonground"

	// KMimeApplicationConferenceInfoXml
	//
	// English:
	//
	//  Application type 'conference-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'conference-info+xml'
	KMimeApplicationConferenceInfoXml Mime = "application/conference-info+xml"

	// KMimeApplicationCplXml
	//
	// English:
	//
	//  Application type 'cpl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'cpl+xml'
	KMimeApplicationCplXml Mime = "application/cpl+xml"

	// KMimeApplicationCose
	//
	// English:
	//
	//  Application type 'cose'
	//
	// Português:
	//
	//  Aplicação tipo 'cose'
	KMimeApplicationCose Mime = "application/cose"

	// KMimeApplicationCoseKey
	//
	// English:
	//
	//  Application type 'cose-key'
	//
	// Português:
	//
	//  Aplicação tipo 'cose-key'
	KMimeApplicationCoseKey Mime = "application/cose-key"

	// KMimeApplicationCoseKeySet
	//
	// English:
	//
	//  Application type 'cose-key-set'
	//
	// Português:
	//
	//  Aplicação tipo 'cose-key-set'
	KMimeApplicationCoseKeySet Mime = "application/cose-key-set"

	// KMimeApplicationCsrattrs
	//
	// English:
	//
	//  Application type 'csrattrs'
	//
	// Português:
	//
	//  Aplicação tipo 'csrattrs'
	KMimeApplicationCsrattrs Mime = "application/csrattrs"

	// KMimeApplicationCstaXml
	//
	// English:
	//
	//  Application type 'csta+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'csta+xml'
	KMimeApplicationCstaXml Mime = "application/csta+xml"

	// KMimeApplicationCSTAdataXml
	//
	// English:
	//
	//  Application type 'CSTAdata+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'CSTAdata+xml'
	KMimeApplicationCSTAdataXml Mime = "application/CSTAdata+xml"

	// KMimeApplicationCsvmJson
	//
	// English:
	//
	//  Application type 'csvm+json'
	//
	// Português:
	//
	//  Aplicação tipo 'csvm+json'
	KMimeApplicationCsvmJson Mime = "application/csvm+json"

	// KMimeApplicationCwt
	//
	// English:
	//
	//  Application type 'cwt'
	//
	// Português:
	//
	//  Aplicação tipo 'cwt'
	KMimeApplicationCwt Mime = "application/cwt"

	// KMimeApplicationCybercash
	//
	// English:
	//
	//  Application type 'cybercash'
	//
	// Português:
	//
	//  Aplicação tipo 'cybercash'
	KMimeApplicationCybercash Mime = "application/cybercash"

	// KMimeApplicationDashXml
	//
	// English:
	//
	//  Application type 'dash+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dash+xml'
	KMimeApplicationDashXml Mime = "application/dash+xml"

	// KMimeApplicationDashPatchXml
	//
	// English:
	//
	//  Application type 'dash-patch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dash-patch+xml'
	KMimeApplicationDashPatchXml Mime = "application/dash-patch+xml"

	// KMimeApplicationDashdelta
	//
	// English:
	//
	//  Application type 'dashdelta'
	//
	// Português:
	//
	//  Aplicação tipo 'dashdelta'
	KMimeApplicationDashdelta Mime = "application/dashdelta"

	// KMimeApplicationDavmountXml
	//
	// English:
	//
	//  Application type 'davmount+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'davmount+xml'
	KMimeApplicationDavmountXml Mime = "application/davmount+xml"

	// KMimeApplicationDcaRft
	//
	// English:
	//
	//  Application type 'dca-rft'
	//
	// Português:
	//
	//  Aplicação tipo 'dca-rft'
	KMimeApplicationDcaRft Mime = "application/dca-rft"

	// KMimeApplicationDCD
	//
	// English:
	//
	//  Application type 'DCD'
	//
	// Português:
	//
	//  Aplicação tipo 'DCD'
	KMimeApplicationDCD Mime = "application/DCD"

	// KMimeApplicationDecDx
	//
	// English:
	//
	//  Application type 'dec-dx'
	//
	// Português:
	//
	//  Aplicação tipo 'dec-dx'
	KMimeApplicationDecDx Mime = "application/dec-dx"

	// KMimeApplicationDialogInfoXml
	//
	// English:
	//
	//  Application type 'dialog-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dialog-info+xml'
	KMimeApplicationDialogInfoXml Mime = "application/dialog-info+xml"

	// KMimeApplicationDicom
	//
	// English:
	//
	//  Application type 'dicom'
	//
	// Português:
	//
	//  Aplicação tipo 'dicom'
	KMimeApplicationDicom Mime = "application/dicom"

	// KMimeApplicationDicomJson
	//
	// English:
	//
	//  Application type 'dicom+json'
	//
	// Português:
	//
	//  Aplicação tipo 'dicom+json'
	KMimeApplicationDicomJson Mime = "application/dicom+json"

	// KMimeApplicationDicomXml
	//
	// English:
	//
	//  Application type 'dicom+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dicom+xml'
	KMimeApplicationDicomXml Mime = "application/dicom+xml"

	// KMimeApplicationDII
	//
	// English:
	//
	//  Application type 'DII'
	//
	// Português:
	//
	//  Aplicação tipo 'DII'
	KMimeApplicationDII Mime = "application/DII"

	// KMimeApplicationDIT
	//
	// English:
	//
	//  Application type 'DIT'
	//
	// Português:
	//
	//  Aplicação tipo 'DIT'
	KMimeApplicationDIT Mime = "application/DIT"

	// KMimeApplicationDns
	//
	// English:
	//
	//  Application type 'dns'
	//
	// Português:
	//
	//  Aplicação tipo 'dns'
	KMimeApplicationDns Mime = "application/dns"

	// KMimeApplicationDnsJson
	//
	// English:
	//
	//  Application type 'dns+json'
	//
	// Português:
	//
	//  Aplicação tipo 'dns+json'
	KMimeApplicationDnsJson Mime = "application/dns+json"

	// KMimeApplicationDnsMessage
	//
	// English:
	//
	//  Application type 'dns-message'
	//
	// Português:
	//
	//  Aplicação tipo 'dns-message'
	KMimeApplicationDnsMessage Mime = "application/dns-message"

	// KMimeApplicationDotsCbor
	//
	// English:
	//
	//  Application type 'dots+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'dots+cbor'
	KMimeApplicationDotsCbor Mime = "application/dots+cbor"

	// KMimeApplicationDskppXml
	//
	// English:
	//
	//  Application type 'dskpp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dskpp+xml'
	KMimeApplicationDskppXml Mime = "application/dskpp+xml"

	// KMimeApplicationDsscDer
	//
	// English:
	//
	//  Application type 'dssc+der'
	//
	// Português:
	//
	//  Aplicação tipo 'dssc+der'
	KMimeApplicationDsscDer Mime = "application/dssc+der"

	// KMimeApplicationDsscXml
	//
	// English:
	//
	//  Application type 'dssc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'dssc+xml'
	KMimeApplicationDsscXml Mime = "application/dssc+xml"

	// KMimeApplicationDvcs
	//
	// English:
	//
	//  Application type 'dvcs'
	//
	// Português:
	//
	//  Aplicação tipo 'dvcs'
	KMimeApplicationDvcs Mime = "application/dvcs"

	// KMimeApplicationEcmascript
	//
	// English:
	//
	//  Application type 'ecmascript'
	//
	// Português:
	//
	//  Aplicação tipo 'ecmascript'
	KMimeApplicationEcmascript Mime = "(OBSOLETED"

	// KMimeApplicationEDIConsent
	//
	// English:
	//
	//  Application type 'EDI-consent'
	//
	// Português:
	//
	//  Aplicação tipo 'EDI-consent'
	KMimeApplicationEDIConsent Mime = "application/EDI-consent"

	// KMimeApplicationEDIFACT
	//
	// English:
	//
	//  Application type 'EDIFACT'
	//
	// Português:
	//
	//  Aplicação tipo 'EDIFACT'
	KMimeApplicationEDIFACT Mime = "application/EDIFACT"

	// KMimeApplicationEDIX12
	//
	// English:
	//
	//  Application type 'EDI-X12'
	//
	// Português:
	//
	//  Aplicação tipo 'EDI-X12'
	KMimeApplicationEDIX12 Mime = "application/EDI-X12"

	// KMimeApplicationEfi
	//
	// English:
	//
	//  Application type 'efi'
	//
	// Português:
	//
	//  Aplicação tipo 'efi'
	KMimeApplicationEfi Mime = "application/efi"

	// KMimeApplicationElmJson
	//
	// English:
	//
	//  Application type 'elm+json'
	//
	// Português:
	//
	//  Aplicação tipo 'elm+json'
	KMimeApplicationElmJson Mime = "application/elm+json"

	// KMimeApplicationElmXml
	//
	// English:
	//
	//  Application type 'elm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'elm+xml'
	KMimeApplicationElmXml Mime = "application/elm+xml"

	// KMimeApplicationEmergencyCallDataCapXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.cap+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.cap+xml'
	KMimeApplicationEmergencyCallDataCapXml Mime = "application/EmergencyCallData.cap+xml"

	// KMimeApplicationEmergencyCallDataCommentXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.Comment+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.Comment+xml'
	KMimeApplicationEmergencyCallDataCommentXml Mime = "application/EmergencyCallData.Comment+xml"

	// KMimeApplicationEmergencyCallDataControlXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.Control+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.Control+xml'
	KMimeApplicationEmergencyCallDataControlXml Mime = "application/EmergencyCallData.Control+xml"

	// KMimeApplicationEmergencyCallDataDeviceInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.DeviceInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.DeviceInfo+xml'
	KMimeApplicationEmergencyCallDataDeviceInfoXml Mime = "application/EmergencyCallData.DeviceInfo+xml"

	// KMimeApplicationEmergencyCallDataECallMSD
	//
	// English:
	//
	//  Application type 'EmergencyCallData.eCall.MSD'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.eCall.MSD'
	KMimeApplicationEmergencyCallDataECallMSD Mime = "application/EmergencyCallData.eCall.MSD"

	// KMimeApplicationEmergencyCallDataProviderInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.ProviderInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.ProviderInfo+xml'
	KMimeApplicationEmergencyCallDataProviderInfoXml Mime = "application/EmergencyCallData.ProviderInfo+xml"

	// KMimeApplicationEmergencyCallDataServiceInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.ServiceInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.ServiceInfo+xml'
	KMimeApplicationEmergencyCallDataServiceInfoXml Mime = "application/EmergencyCallData.ServiceInfo+xml"

	// KMimeApplicationEmergencyCallDataSubscriberInfoXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.SubscriberInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.SubscriberInfo+xml'
	KMimeApplicationEmergencyCallDataSubscriberInfoXml Mime = "application/EmergencyCallData.SubscriberInfo+xml"

	// KMimeApplicationEmergencyCallDataVEDSXml
	//
	// English:
	//
	//  Application type 'EmergencyCallData.VEDS+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'EmergencyCallData.VEDS+xml'
	KMimeApplicationEmergencyCallDataVEDSXml Mime = "application/EmergencyCallData.VEDS+xml"

	// KMimeApplicationEmmaXml
	//
	// English:
	//
	//  Application type 'emma+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'emma+xml'
	KMimeApplicationEmmaXml Mime = "application/emma+xml"

	// KMimeApplicationEmotionmlXml
	//
	// English:
	//
	//  Application type 'emotionml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'emotionml+xml'
	KMimeApplicationEmotionmlXml Mime = "application/emotionml+xml"

	// KMimeApplicationEncaprtp
	//
	// English:
	//
	//  Application type 'encaprtp'
	//
	// Português:
	//
	//  Aplicação tipo 'encaprtp'
	KMimeApplicationEncaprtp Mime = "application/encaprtp"

	// KMimeApplicationEppXml
	//
	// English:
	//
	//  Application type 'epp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'epp+xml'
	KMimeApplicationEppXml Mime = "application/epp+xml"

	// KMimeApplicationEpubZip
	//
	// English:
	//
	//  Application type 'epub+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'epub+zip'
	KMimeApplicationEpubZip Mime = "application/epub+zip"

	// KMimeApplicationEshop
	//
	// English:
	//
	//  Application type 'eshop'
	//
	// Português:
	//
	//  Aplicação tipo 'eshop'
	KMimeApplicationEshop Mime = "application/eshop"

	// KMimeApplicationExample
	//
	// English:
	//
	//  Application type 'example'
	//
	// Português:
	//
	//  Aplicação tipo 'example'
	KMimeApplicationExample Mime = "application/example"

	// KMimeApplicationExi
	//
	// English:
	//
	//  Application type 'exi'
	//
	// Português:
	//
	//  Aplicação tipo 'exi'
	KMimeApplicationExi Mime = "application/exi"

	// KMimeApplicationExpectCtReportJson
	//
	// English:
	//
	//  Application type 'expect-ct-report+json'
	//
	// Português:
	//
	//  Aplicação tipo 'expect-ct-report+json'
	KMimeApplicationExpectCtReportJson Mime = "application/expect-ct-report+json"

	// KMimeApplicationExpress
	//
	// English:
	//
	//  Application type 'express'
	//
	// Português:
	//
	//  Aplicação tipo 'express'
	KMimeApplicationExpress Mime = "application/express"

	// KMimeApplicationFastinfoset
	//
	// English:
	//
	//  Application type 'fastinfoset'
	//
	// Português:
	//
	//  Aplicação tipo 'fastinfoset'
	KMimeApplicationFastinfoset Mime = "application/fastinfoset"

	// KMimeApplicationFastsoap
	//
	// English:
	//
	//  Application type 'fastsoap'
	//
	// Português:
	//
	//  Aplicação tipo 'fastsoap'
	KMimeApplicationFastsoap Mime = "application/fastsoap"

	// KMimeApplicationFdf
	//
	// English:
	//
	//  Application type 'fdf'
	//
	// Português:
	//
	//  Aplicação tipo 'fdf'
	KMimeApplicationFdf Mime = "application/fdf"

	// KMimeApplicationFdtXml
	//
	// English:
	//
	//  Application type 'fdt+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'fdt+xml'
	KMimeApplicationFdtXml Mime = "application/fdt+xml"

	// KMimeApplicationFhirJson
	//
	// English:
	//
	//  Application type 'fhir+json'
	//
	// Português:
	//
	//  Aplicação tipo 'fhir+json'
	KMimeApplicationFhirJson Mime = "application/fhir+json"

	// KMimeApplicationFhirXml
	//
	// English:
	//
	//  Application type 'fhir+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'fhir+xml'
	KMimeApplicationFhirXml Mime = "application/fhir+xml"

	// KMimeApplicationFits
	//
	// English:
	//
	//  Application type 'fits'
	//
	// Português:
	//
	//  Aplicação tipo 'fits'
	KMimeApplicationFits Mime = "application/fits"

	// KMimeApplicationFlexfec
	//
	// English:
	//
	//  Application type 'flexfec'
	//
	// Português:
	//
	//  Aplicação tipo 'flexfec'
	KMimeApplicationFlexfec Mime = "application/flexfec"

	// KMimeApplicationFontSfnt
	//
	// English:
	//
	//  Application type 'font-sfnt'
	//
	// Português:
	//
	//  Aplicação tipo 'font-sfnt'
	KMimeApplicationFontSfnt Mime = "-"

	// KMimeApplicationFontTdpfr
	//
	// English:
	//
	//  Application type 'font-tdpfr'
	//
	// Português:
	//
	//  Aplicação tipo 'font-tdpfr'
	KMimeApplicationFontTdpfr Mime = "application/font-tdpfr"

	// KMimeApplicationFontWoff
	//
	// English:
	//
	//  Application type 'font-woff'
	//
	// Português:
	//
	//  Aplicação tipo 'font-woff'
	KMimeApplicationFontWoff Mime = "-"

	// KMimeApplicationFrameworkAttributesXml
	//
	// English:
	//
	//  Application type 'framework-attributes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'framework-attributes+xml'
	KMimeApplicationFrameworkAttributesXml Mime = "application/framework-attributes+xml"

	// KMimeApplicationGeoJson
	//
	// English:
	//
	//  Application type 'geo+json'
	//
	// Português:
	//
	//  Aplicação tipo 'geo+json'
	KMimeApplicationGeoJson Mime = "application/geo+json"

	// KMimeApplicationGeoJsonSeq
	//
	// English:
	//
	//  Application type 'geo+json-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'geo+json-seq'
	KMimeApplicationGeoJsonSeq Mime = "application/geo+json-seq"

	// KMimeApplicationGeopackageSqlite3
	//
	// English:
	//
	//  Application type 'geopackage+sqlite3'
	//
	// Português:
	//
	//  Aplicação tipo 'geopackage+sqlite3'
	KMimeApplicationGeopackageSqlite3 Mime = "application/geopackage+sqlite3"

	// KMimeApplicationGeoxacmlXml
	//
	// English:
	//
	//  Application type 'geoxacml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'geoxacml+xml'
	KMimeApplicationGeoxacmlXml Mime = "application/geoxacml+xml"

	// KMimeApplicationGltfBuffer
	//
	// English:
	//
	//  Application type 'gltf-buffer'
	//
	// Português:
	//
	//  Aplicação tipo 'gltf-buffer'
	KMimeApplicationGltfBuffer Mime = "application/gltf-buffer"

	// KMimeApplicationGmlXml
	//
	// English:
	//
	//  Application type 'gml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'gml+xml'
	KMimeApplicationGmlXml Mime = "application/gml+xml"

	// KMimeApplicationGzip
	//
	// English:
	//
	//  Application type 'gzip'
	//
	// Português:
	//
	//  Aplicação tipo 'gzip'
	KMimeApplicationGzip Mime = "application/gzip"

	// KMimeApplicationH224
	//
	// English:
	//
	//  Application type 'H224'
	//
	// Português:
	//
	//  Aplicação tipo 'H224'
	KMimeApplicationH224 Mime = "application/H224"

	// KMimeApplicationHeldXml
	//
	// English:
	//
	//  Application type 'held+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'held+xml'
	KMimeApplicationHeldXml Mime = "application/held+xml"

	// KMimeApplicationHl7v2Xml
	//
	// English:
	//
	//  Application type 'hl7v2+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'hl7v2+xml'
	KMimeApplicationHl7v2Xml Mime = "application/hl7v2+xml"

	// KMimeApplicationHttp
	//
	// English:
	//
	//  Application type 'http'
	//
	// Português:
	//
	//  Aplicação tipo 'http'
	KMimeApplicationHttp Mime = "application/http"

	// KMimeApplicationHyperstudio
	//
	// English:
	//
	//  Application type 'hyperstudio'
	//
	// Português:
	//
	//  Aplicação tipo 'hyperstudio'
	KMimeApplicationHyperstudio Mime = "application/hyperstudio"

	// KMimeApplicationIbeKeyRequestXml
	//
	// English:
	//
	//  Application type 'ibe-key-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ibe-key-request+xml'
	KMimeApplicationIbeKeyRequestXml Mime = "application/ibe-key-request+xml"

	// KMimeApplicationIbePkgReplyXml
	//
	// English:
	//
	//  Application type 'ibe-pkg-reply+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ibe-pkg-reply+xml'
	KMimeApplicationIbePkgReplyXml Mime = "application/ibe-pkg-reply+xml"

	// KMimeApplicationIbePpData
	//
	// English:
	//
	//  Application type 'ibe-pp-data'
	//
	// Português:
	//
	//  Aplicação tipo 'ibe-pp-data'
	KMimeApplicationIbePpData Mime = "application/ibe-pp-data"

	// KMimeApplicationIges
	//
	// English:
	//
	//  Application type 'iges'
	//
	// Português:
	//
	//  Aplicação tipo 'iges'
	KMimeApplicationIges Mime = "application/iges"

	// KMimeApplicationImIscomposingXml
	//
	// English:
	//
	//  Application type 'im-iscomposing+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'im-iscomposing+xml'
	KMimeApplicationImIscomposingXml Mime = "application/im-iscomposing+xml"

	// KMimeApplicationIndex
	//
	// English:
	//
	//  Application type 'index'
	//
	// Português:
	//
	//  Aplicação tipo 'index'
	KMimeApplicationIndex Mime = "application/index"

	// KMimeApplicationIndexCmd
	//
	// English:
	//
	//  Application type 'index.cmd'
	//
	// Português:
	//
	//  Aplicação tipo 'index.cmd'
	KMimeApplicationIndexCmd Mime = "application/index.cmd"

	// KMimeApplicationIndexObj
	//
	// English:
	//
	//  Application type 'index.obj'
	//
	// Português:
	//
	//  Aplicação tipo 'index.obj'
	KMimeApplicationIndexObj Mime = "application/index.obj"

	// KMimeApplicationIndexResponse
	//
	// English:
	//
	//  Application type 'index.response'
	//
	// Português:
	//
	//  Aplicação tipo 'index.response'
	KMimeApplicationIndexResponse Mime = "application/index.response"

	// KMimeApplicationIndexVnd
	//
	// English:
	//
	//  Application type 'index.vnd'
	//
	// Português:
	//
	//  Aplicação tipo 'index.vnd'
	KMimeApplicationIndexVnd Mime = "application/index.vnd"

	// KMimeApplicationInkmlXml
	//
	// English:
	//
	//  Application type 'inkml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'inkml+xml'
	KMimeApplicationInkmlXml Mime = "application/inkml+xml"

	// KMimeApplicationIOTP
	//
	// English:
	//
	//  Application type 'IOTP'
	//
	// Português:
	//
	//  Aplicação tipo 'IOTP'
	KMimeApplicationIOTP Mime = "application/IOTP"

	// KMimeApplicationIpfix
	//
	// English:
	//
	//  Application type 'ipfix'
	//
	// Português:
	//
	//  Aplicação tipo 'ipfix'
	KMimeApplicationIpfix Mime = "application/ipfix"

	// KMimeApplicationIpp
	//
	// English:
	//
	//  Application type 'ipp'
	//
	// Português:
	//
	//  Aplicação tipo 'ipp'
	KMimeApplicationIpp Mime = "application/ipp"

	// KMimeApplicationISUP
	//
	// English:
	//
	//  Application type 'ISUP'
	//
	// Português:
	//
	//  Aplicação tipo 'ISUP'
	KMimeApplicationISUP Mime = "application/ISUP"

	// KMimeApplicationItsXml
	//
	// English:
	//
	//  Application type 'its+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'its+xml'
	KMimeApplicationItsXml Mime = "application/its+xml"

	// KMimeApplicationJavascript
	//
	// English:
	//
	//  Application type 'javascript'
	//
	// Português:
	//
	//  Aplicação tipo 'javascript'
	KMimeApplicationJavascript Mime = "(OBSOLETED"

	// KMimeApplicationJf2feedJson
	//
	// English:
	//
	//  Application type 'jf2feed+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jf2feed+json'
	KMimeApplicationJf2feedJson Mime = "application/jf2feed+json"

	// KMimeApplicationJose
	//
	// English:
	//
	//  Application type 'jose'
	//
	// Português:
	//
	//  Aplicação tipo 'jose'
	KMimeApplicationJose Mime = "application/jose"

	// KMimeApplicationJoseJson
	//
	// English:
	//
	//  Application type 'jose+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jose+json'
	KMimeApplicationJoseJson Mime = "application/jose+json"

	// KMimeApplicationJrdJson
	//
	// English:
	//
	//  Application type 'jrd+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jrd+json'
	KMimeApplicationJrdJson Mime = "application/jrd+json"

	// KMimeApplicationJscalendarJson
	//
	// English:
	//
	//  Application type 'jscalendar+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jscalendar+json'
	KMimeApplicationJscalendarJson Mime = "application/jscalendar+json"

	// KMimeApplicationJson
	//
	// English:
	//
	//  Application type 'json'
	//
	// Português:
	//
	//  Aplicação tipo 'json'
	KMimeApplicationJson Mime = "application/json"

	// KMimeApplicationJsonPatchJson
	//
	// English:
	//
	//  Application type 'json-patch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'json-patch+json'
	KMimeApplicationJsonPatchJson Mime = "application/json-patch+json"

	// KMimeApplicationJsonSeq
	//
	// English:
	//
	//  Application type 'json-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'json-seq'
	KMimeApplicationJsonSeq Mime = "application/json-seq"

	// KMimeApplicationJwkJson
	//
	// English:
	//
	//  Application type 'jwk+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jwk+json'
	KMimeApplicationJwkJson Mime = "application/jwk+json"

	// KMimeApplicationJwkSetJson
	//
	// English:
	//
	//  Application type 'jwk-set+json'
	//
	// Português:
	//
	//  Aplicação tipo 'jwk-set+json'
	KMimeApplicationJwkSetJson Mime = "application/jwk-set+json"

	// KMimeApplicationJwt
	//
	// English:
	//
	//  Application type 'jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'jwt'
	KMimeApplicationJwt Mime = "application/jwt"

	// KMimeApplicationKpmlRequestXml
	//
	// English:
	//
	//  Application type 'kpml-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'kpml-request+xml'
	KMimeApplicationKpmlRequestXml Mime = "application/kpml-request+xml"

	// KMimeApplicationKpmlResponseXml
	//
	// English:
	//
	//  Application type 'kpml-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'kpml-response+xml'
	KMimeApplicationKpmlResponseXml Mime = "application/kpml-response+xml"

	// KMimeApplicationLdJson
	//
	// English:
	//
	//  Application type 'ld+json'
	//
	// Português:
	//
	//  Aplicação tipo 'ld+json'
	KMimeApplicationLdJson Mime = "application/ld+json"

	// KMimeApplicationLgrXml
	//
	// English:
	//
	//  Application type 'lgr+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'lgr+xml'
	KMimeApplicationLgrXml Mime = "application/lgr+xml"

	// KMimeApplicationLinkFormat
	//
	// English:
	//
	//  Application type 'link-format'
	//
	// Português:
	//
	//  Aplicação tipo 'link-format'
	KMimeApplicationLinkFormat Mime = "application/link-format"

	// KMimeApplicationLoadControlXml
	//
	// English:
	//
	//  Application type 'load-control+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'load-control+xml'
	KMimeApplicationLoadControlXml Mime = "application/load-control+xml"

	// KMimeApplicationLostXml
	//
	// English:
	//
	//  Application type 'lost+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'lost+xml'
	KMimeApplicationLostXml Mime = "application/lost+xml"

	// KMimeApplicationLostsyncXml
	//
	// English:
	//
	//  Application type 'lostsync+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'lostsync+xml'
	KMimeApplicationLostsyncXml Mime = "application/lostsync+xml"

	// KMimeApplicationLpfZip
	//
	// English:
	//
	//  Application type 'lpf+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'lpf+zip'
	KMimeApplicationLpfZip Mime = "application/lpf+zip"

	// KMimeApplicationLXF
	//
	// English:
	//
	//  Application type 'LXF'
	//
	// Português:
	//
	//  Aplicação tipo 'LXF'
	KMimeApplicationLXF Mime = "application/LXF"

	// KMimeApplicationMacBinhex40
	//
	// English:
	//
	//  Application type 'mac-binhex40'
	//
	// Português:
	//
	//  Aplicação tipo 'mac-binhex40'
	KMimeApplicationMacBinhex40 Mime = "application/mac-binhex40"

	// KMimeApplicationMacwriteii
	//
	// English:
	//
	//  Application type 'macwriteii'
	//
	// Português:
	//
	//  Aplicação tipo 'macwriteii'
	KMimeApplicationMacwriteii Mime = "application/macwriteii"

	// KMimeApplicationMadsXml
	//
	// English:
	//
	//  Application type 'mads+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mads+xml'
	KMimeApplicationMadsXml Mime = "application/mads+xml"

	// KMimeApplicationManifestJson
	//
	// English:
	//
	//  Application type 'manifest+json'
	//
	// Português:
	//
	//  Aplicação tipo 'manifest+json'
	KMimeApplicationManifestJson Mime = "application/manifest+json"

	// KMimeApplicationMarc
	//
	// English:
	//
	//  Application type 'marc'
	//
	// Português:
	//
	//  Aplicação tipo 'marc'
	KMimeApplicationMarc Mime = "application/marc"

	// KMimeApplicationMarcxmlXml
	//
	// English:
	//
	//  Application type 'marcxml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'marcxml+xml'
	KMimeApplicationMarcxmlXml Mime = "application/marcxml+xml"

	// KMimeApplicationMathematica
	//
	// English:
	//
	//  Application type 'mathematica'
	//
	// Português:
	//
	//  Aplicação tipo 'mathematica'
	KMimeApplicationMathematica Mime = "application/mathematica"

	// KMimeApplicationMathmlXml
	//
	// English:
	//
	//  Application type 'mathml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mathml+xml'
	KMimeApplicationMathmlXml Mime = "application/mathml+xml"

	// KMimeApplicationMathmlContentXml
	//
	// English:
	//
	//  Application type 'mathml-content+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mathml-content+xml'
	KMimeApplicationMathmlContentXml Mime = "application/mathml-content+xml"

	// KMimeApplicationMathmlPresentationXml
	//
	// English:
	//
	//  Application type 'mathml-presentation+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mathml-presentation+xml'
	KMimeApplicationMathmlPresentationXml Mime = "application/mathml-presentation+xml"

	// KMimeApplicationMbmsAssociatedProcedureDescriptionXml
	//
	// English:
	//
	//  Application type 'mbms-associated-procedure-description+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-associated-procedure-description+xml'
	KMimeApplicationMbmsAssociatedProcedureDescriptionXml Mime = "application/mbms-associated-procedure-description+xml"

	// KMimeApplicationMbmsDeregisterXml
	//
	// English:
	//
	//  Application type 'mbms-deregister+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-deregister+xml'
	KMimeApplicationMbmsDeregisterXml Mime = "application/mbms-deregister+xml"

	// KMimeApplicationMbmsEnvelopeXml
	//
	// English:
	//
	//  Application type 'mbms-envelope+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-envelope+xml'
	KMimeApplicationMbmsEnvelopeXml Mime = "application/mbms-envelope+xml"

	// KMimeApplicationMbmsMskResponseXml
	//
	// English:
	//
	//  Application type 'mbms-msk-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-msk-response+xml'
	KMimeApplicationMbmsMskResponseXml Mime = "application/mbms-msk-response+xml"

	// KMimeApplicationMbmsMskXml
	//
	// English:
	//
	//  Application type 'mbms-msk+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-msk+xml'
	KMimeApplicationMbmsMskXml Mime = "application/mbms-msk+xml"

	// KMimeApplicationMbmsProtectionDescriptionXml
	//
	// English:
	//
	//  Application type 'mbms-protection-description+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-protection-description+xml'
	KMimeApplicationMbmsProtectionDescriptionXml Mime = "application/mbms-protection-description+xml"

	// KMimeApplicationMbmsReceptionReportXml
	//
	// English:
	//
	//  Application type 'mbms-reception-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-reception-report+xml'
	KMimeApplicationMbmsReceptionReportXml Mime = "application/mbms-reception-report+xml"

	// KMimeApplicationMbmsRegisterResponseXml
	//
	// English:
	//
	//  Application type 'mbms-register-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-register-response+xml'
	KMimeApplicationMbmsRegisterResponseXml Mime = "application/mbms-register-response+xml"

	// KMimeApplicationMbmsRegisterXml
	//
	// English:
	//
	//  Application type 'mbms-register+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-register+xml'
	KMimeApplicationMbmsRegisterXml Mime = "application/mbms-register+xml"

	// KMimeApplicationMbmsScheduleXml
	//
	// English:
	//
	//  Application type 'mbms-schedule+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-schedule+xml'
	KMimeApplicationMbmsScheduleXml Mime = "application/mbms-schedule+xml"

	// KMimeApplicationMbmsUserServiceDescriptionXml
	//
	// English:
	//
	//  Application type 'mbms-user-service-description+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mbms-user-service-description+xml'
	KMimeApplicationMbmsUserServiceDescriptionXml Mime = "application/mbms-user-service-description+xml"

	// KMimeApplicationMbox
	//
	// English:
	//
	//  Application type 'mbox'
	//
	// Português:
	//
	//  Aplicação tipo 'mbox'
	KMimeApplicationMbox Mime = "application/mbox"

	// KMimeApplicationMediaControlXml
	//
	// English:
	//
	//  Application type 'media_control+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'media_control+xml'
	KMimeApplicationMediaControlXml Mime = "application/media_control+xml"

	// KMimeApplicationMediaPolicyDatasetXml
	//
	// English:
	//
	//  Application type 'media-policy-dataset+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'media-policy-dataset+xml'
	KMimeApplicationMediaPolicyDatasetXml Mime = "application/media-policy-dataset+xml"

	// KMimeApplicationMediaservercontrolXml
	//
	// English:
	//
	//  Application type 'mediaservercontrol+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mediaservercontrol+xml'
	KMimeApplicationMediaservercontrolXml Mime = "application/mediaservercontrol+xml"

	// KMimeApplicationMergePatchJson
	//
	// English:
	//
	//  Application type 'merge-patch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'merge-patch+json'
	KMimeApplicationMergePatchJson Mime = "application/merge-patch+json"

	// KMimeApplicationMetalink4Xml
	//
	// English:
	//
	//  Application type 'metalink4+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'metalink4+xml'
	KMimeApplicationMetalink4Xml Mime = "application/metalink4+xml"

	// KMimeApplicationMetsXml
	//
	// English:
	//
	//  Application type 'mets+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mets+xml'
	KMimeApplicationMetsXml Mime = "application/mets+xml"

	// KMimeApplicationMF4
	//
	// English:
	//
	//  Application type 'MF4'
	//
	// Português:
	//
	//  Aplicação tipo 'MF4'
	KMimeApplicationMF4 Mime = "application/MF4"

	// KMimeApplicationMikey
	//
	// English:
	//
	//  Application type 'mikey'
	//
	// Português:
	//
	//  Aplicação tipo 'mikey'
	KMimeApplicationMikey Mime = "application/mikey"

	// KMimeApplicationMipc
	//
	// English:
	//
	//  Application type 'mipc'
	//
	// Português:
	//
	//  Aplicação tipo 'mipc'
	KMimeApplicationMipc Mime = "application/mipc"

	// KMimeApplicationMissingBlocksCborSeq
	//
	// English:
	//
	//  Application type 'missing-blocks+cbor-seq'
	//
	// Português:
	//
	//  Aplicação tipo 'missing-blocks+cbor-seq'
	KMimeApplicationMissingBlocksCborSeq Mime = "application/missing-blocks+cbor-seq"

	// KMimeApplicationMmtAeiXml
	//
	// English:
	//
	//  Application type 'mmt-aei+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mmt-aei+xml'
	KMimeApplicationMmtAeiXml Mime = "application/mmt-aei+xml"

	// KMimeApplicationMmtUsdXml
	//
	// English:
	//
	//  Application type 'mmt-usd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mmt-usd+xml'
	KMimeApplicationMmtUsdXml Mime = "application/mmt-usd+xml"

	// KMimeApplicationModsXml
	//
	// English:
	//
	//  Application type 'mods+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mods+xml'
	KMimeApplicationModsXml Mime = "application/mods+xml"

	// KMimeApplicationMossKeys
	//
	// English:
	//
	//  Application type 'moss-keys'
	//
	// Português:
	//
	//  Aplicação tipo 'moss-keys'
	KMimeApplicationMossKeys Mime = "application/moss-keys"

	// KMimeApplicationMossSignature
	//
	// English:
	//
	//  Application type 'moss-signature'
	//
	// Português:
	//
	//  Aplicação tipo 'moss-signature'
	KMimeApplicationMossSignature Mime = "application/moss-signature"

	// KMimeApplicationMosskeyData
	//
	// English:
	//
	//  Application type 'mosskey-data'
	//
	// Português:
	//
	//  Aplicação tipo 'mosskey-data'
	KMimeApplicationMosskeyData Mime = "application/mosskey-data"

	// KMimeApplicationMosskeyRequest
	//
	// English:
	//
	//  Application type 'mosskey-request'
	//
	// Português:
	//
	//  Aplicação tipo 'mosskey-request'
	KMimeApplicationMosskeyRequest Mime = "application/mosskey-request"

	// KMimeApplicationMp21
	//
	// English:
	//
	//  Application type 'mp21'
	//
	// Português:
	//
	//  Aplicação tipo 'mp21'
	KMimeApplicationMp21 Mime = "application/mp21"

	// KMimeApplicationMp4
	//
	// English:
	//
	//  Application type 'mp4'
	//
	// Português:
	//
	//  Aplicação tipo 'mp4'
	KMimeApplicationMp4 Mime = "application/mp4"

	// KMimeApplicationMpeg4Generic
	//
	// English:
	//
	//  Application type 'mpeg4-generic'
	//
	// Português:
	//
	//  Aplicação tipo 'mpeg4-generic'
	KMimeApplicationMpeg4Generic Mime = "application/mpeg4-generic"

	// KMimeApplicationMpeg4Iod
	//
	// English:
	//
	//  Application type 'mpeg4-iod'
	//
	// Português:
	//
	//  Aplicação tipo 'mpeg4-iod'
	KMimeApplicationMpeg4Iod Mime = "application/mpeg4-iod"

	// KMimeApplicationMpeg4IodXmt
	//
	// English:
	//
	//  Application type 'mpeg4-iod-xmt'
	//
	// Português:
	//
	//  Aplicação tipo 'mpeg4-iod-xmt'
	KMimeApplicationMpeg4IodXmt Mime = "application/mpeg4-iod-xmt"

	// KMimeApplicationMrbConsumerXml
	//
	// English:
	//
	//  Application type 'mrb-consumer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mrb-consumer+xml'
	KMimeApplicationMrbConsumerXml Mime = "application/mrb-consumer+xml"

	// KMimeApplicationMrbPublishXml
	//
	// English:
	//
	//  Application type 'mrb-publish+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'mrb-publish+xml'
	KMimeApplicationMrbPublishXml Mime = "application/mrb-publish+xml"

	// KMimeApplicationMscIvrXml
	//
	// English:
	//
	//  Application type 'msc-ivr+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'msc-ivr+xml'
	KMimeApplicationMscIvrXml Mime = "application/msc-ivr+xml"

	// KMimeApplicationMscMixerXml
	//
	// English:
	//
	//  Application type 'msc-mixer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'msc-mixer+xml'
	KMimeApplicationMscMixerXml Mime = "application/msc-mixer+xml"

	// KMimeApplicationMsword
	//
	// English:
	//
	//  Application type 'msword'
	//
	// Português:
	//
	//  Aplicação tipo 'msword'
	KMimeApplicationMsword Mime = "application/msword"

	// KMimeApplicationMudJson
	//
	// English:
	//
	//  Application type 'mud+json'
	//
	// Português:
	//
	//  Aplicação tipo 'mud+json'
	KMimeApplicationMudJson Mime = "application/mud+json"

	// KMimeApplicationMultipartCore
	//
	// English:
	//
	//  Application type 'multipart-core'
	//
	// Português:
	//
	//  Aplicação tipo 'multipart-core'
	KMimeApplicationMultipartCore Mime = "application/multipart-core"

	// KMimeApplicationMxf
	//
	// English:
	//
	//  Application type 'mxf'
	//
	// Português:
	//
	//  Aplicação tipo 'mxf'
	KMimeApplicationMxf Mime = "application/mxf"

	// KMimeApplicationNQuads
	//
	// English:
	//
	//  Application type 'n-quads'
	//
	// Português:
	//
	//  Aplicação tipo 'n-quads'
	KMimeApplicationNQuads Mime = "application/n-quads"

	// KMimeApplicationNTriples
	//
	// English:
	//
	//  Application type 'n-triples'
	//
	// Português:
	//
	//  Aplicação tipo 'n-triples'
	KMimeApplicationNTriples Mime = "application/n-triples"

	// KMimeApplicationNasdata
	//
	// English:
	//
	//  Application type 'nasdata'
	//
	// Português:
	//
	//  Aplicação tipo 'nasdata'
	KMimeApplicationNasdata Mime = "application/nasdata"

	// KMimeApplicationNewsCheckgroups
	//
	// English:
	//
	//  Application type 'news-checkgroups'
	//
	// Português:
	//
	//  Aplicação tipo 'news-checkgroups'
	KMimeApplicationNewsCheckgroups Mime = "application/news-checkgroups"

	// KMimeApplicationNewsGroupinfo
	//
	// English:
	//
	//  Application type 'news-groupinfo'
	//
	// Português:
	//
	//  Aplicação tipo 'news-groupinfo'
	KMimeApplicationNewsGroupinfo Mime = "application/news-groupinfo"

	// KMimeApplicationNewsTransmission
	//
	// English:
	//
	//  Application type 'news-transmission'
	//
	// Português:
	//
	//  Aplicação tipo 'news-transmission'
	KMimeApplicationNewsTransmission Mime = "application/news-transmission"

	// KMimeApplicationNlsmlXml
	//
	// English:
	//
	//  Application type 'nlsml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'nlsml+xml'
	KMimeApplicationNlsmlXml Mime = "application/nlsml+xml"

	// KMimeApplicationNode
	//
	// English:
	//
	//  Application type 'node'
	//
	// Português:
	//
	//  Aplicação tipo 'node'
	KMimeApplicationNode Mime = "application/node"

	// KMimeApplicationNss
	//
	// English:
	//
	//  Application type 'nss'
	//
	// Português:
	//
	//  Aplicação tipo 'nss'
	KMimeApplicationNss Mime = "application/nss"

	// KMimeApplicationOauthAuthzReqJwt
	//
	// English:
	//
	//  Application type 'oauth-authz-req+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'oauth-authz-req+jwt'
	KMimeApplicationOauthAuthzReqJwt Mime = "application/oauth-authz-req+jwt"

	// KMimeApplicationObliviousDnsMessage
	//
	// English:
	//
	//  Application type 'oblivious-dns-message'
	//
	// Português:
	//
	//  Aplicação tipo 'oblivious-dns-message'
	KMimeApplicationObliviousDnsMessage Mime = "application/oblivious-dns-message"

	// KMimeApplicationOcspRequest
	//
	// English:
	//
	//  Application type 'ocsp-request'
	//
	// Português:
	//
	//  Aplicação tipo 'ocsp-request'
	KMimeApplicationOcspRequest Mime = "application/ocsp-request"

	// KMimeApplicationOcspResponse
	//
	// English:
	//
	//  Application type 'ocsp-response'
	//
	// Português:
	//
	//  Aplicação tipo 'ocsp-response'
	KMimeApplicationOcspResponse Mime = "application/ocsp-response"

	// KMimeApplicationOctetStream
	//
	// English:
	//
	//  Application type 'octet-stream'
	//
	// Português:
	//
	//  Aplicação tipo 'octet-stream'
	KMimeApplicationOctetStream Mime = "application/octet-stream"

	// KMimeApplicationODA
	//
	// English:
	//
	//  Application type 'ODA'
	//
	// Português:
	//
	//  Aplicação tipo 'ODA'
	KMimeApplicationODA Mime = "application/ODA"

	// KMimeApplicationOdmXml
	//
	// English:
	//
	//  Application type 'odm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'odm+xml'
	KMimeApplicationOdmXml Mime = "application/odm+xml"

	// KMimeApplicationODX
	//
	// English:
	//
	//  Application type 'ODX'
	//
	// Português:
	//
	//  Aplicação tipo 'ODX'
	KMimeApplicationODX Mime = "application/ODX"

	// KMimeApplicationOebpsPackageXml
	//
	// English:
	//
	//  Application type 'oebps-package+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'oebps-package+xml'
	KMimeApplicationOebpsPackageXml Mime = "application/oebps-package+xml"

	// KMimeApplicationOgg
	//
	// English:
	//
	//  Application type 'ogg'
	//
	// Português:
	//
	//  Aplicação tipo 'ogg'
	KMimeApplicationOgg Mime = "application/ogg"

	// KMimeApplicationOpcNodesetXml
	//
	// English:
	//
	//  Application type 'opc-nodeset+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'opc-nodeset+xml'
	KMimeApplicationOpcNodesetXml Mime = "application/opc-nodeset+xml"

	// KMimeApplicationOscore
	//
	// English:
	//
	//  Application type 'oscore'
	//
	// Português:
	//
	//  Aplicação tipo 'oscore'
	KMimeApplicationOscore Mime = "application/oscore"

	// KMimeApplicationOxps
	//
	// English:
	//
	//  Application type 'oxps'
	//
	// Português:
	//
	//  Aplicação tipo 'oxps'
	KMimeApplicationOxps Mime = "application/oxps"

	// KMimeApplicationP21
	//
	// English:
	//
	//  Application type 'p21'
	//
	// Português:
	//
	//  Aplicação tipo 'p21'
	KMimeApplicationP21 Mime = "application/p21"

	// KMimeApplicationP21Zip
	//
	// English:
	//
	//  Application type 'p21+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'p21+zip'
	KMimeApplicationP21Zip Mime = "application/p21+zip"

	// KMimeApplicationP2pOverlayXml
	//
	// English:
	//
	//  Application type 'p2p-overlay+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'p2p-overlay+xml'
	KMimeApplicationP2pOverlayXml Mime = "application/p2p-overlay+xml"

	// KMimeApplicationParityfec
	//
	// English:
	//
	//  Application type 'parityfec'
	//
	// Português:
	//
	//  Aplicação tipo 'parityfec'
	KMimeApplicationParityfec Mime = "application/parityfec"

	// KMimeApplicationPassport
	//
	// English:
	//
	//  Application type 'passport'
	//
	// Português:
	//
	//  Aplicação tipo 'passport'
	KMimeApplicationPassport Mime = "application/passport"

	// KMimeApplicationPatchOpsErrorXml
	//
	// English:
	//
	//  Application type 'patch-ops-error+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'patch-ops-error+xml'
	KMimeApplicationPatchOpsErrorXml Mime = "application/patch-ops-error+xml"

	// KMimeApplicationPdf
	//
	// English:
	//
	//  Application type 'pdf'
	//
	// Português:
	//
	//  Aplicação tipo 'pdf'
	KMimeApplicationPdf Mime = "application/pdf"

	// KMimeApplicationPDX
	//
	// English:
	//
	//  Application type 'PDX'
	//
	// Português:
	//
	//  Aplicação tipo 'PDX'
	KMimeApplicationPDX Mime = "application/PDX"

	// KMimeApplicationPemCertificateChain
	//
	// English:
	//
	//  Application type 'pem-certificate-chain'
	//
	// Português:
	//
	//  Aplicação tipo 'pem-certificate-chain'
	KMimeApplicationPemCertificateChain Mime = "application/pem-certificate-chain"

	// KMimeApplicationPgpEncrypted
	//
	// English:
	//
	//  Application type 'pgp-encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'pgp-encrypted'
	KMimeApplicationPgpEncrypted Mime = "application/pgp-encrypted"

	// KMimeApplicationPgpKeys
	//
	// English:
	//
	//  Application type 'pgp-keys'
	//
	// Português:
	//
	//  Aplicação tipo 'pgp-keys'
	KMimeApplicationPgpKeys Mime = "application/pgp-keys"

	// KMimeApplicationPgpSignature
	//
	// English:
	//
	//  Application type 'pgp-signature'
	//
	// Português:
	//
	//  Aplicação tipo 'pgp-signature'
	KMimeApplicationPgpSignature Mime = "application/pgp-signature"

	// KMimeApplicationPidfDiffXml
	//
	// English:
	//
	//  Application type 'pidf-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pidf-diff+xml'
	KMimeApplicationPidfDiffXml Mime = "application/pidf-diff+xml"

	// KMimeApplicationPidfXml
	//
	// English:
	//
	//  Application type 'pidf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pidf+xml'
	KMimeApplicationPidfXml Mime = "application/pidf+xml"

	// KMimeApplicationPkcs10
	//
	// English:
	//
	//  Application type 'pkcs10'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs10'
	KMimeApplicationPkcs10 Mime = "application/pkcs10"

	// KMimeApplicationPkcs7Mime
	//
	// English:
	//
	//  Application type 'pkcs7-mime'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs7-mime'
	KMimeApplicationPkcs7Mime Mime = "application/pkcs7-mime"

	// KMimeApplicationPkcs7Signature
	//
	// English:
	//
	//  Application type 'pkcs7-signature'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs7-signature'
	KMimeApplicationPkcs7Signature Mime = "application/pkcs7-signature"

	// KMimeApplicationPkcs8
	//
	// English:
	//
	//  Application type 'pkcs8'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs8'
	KMimeApplicationPkcs8 Mime = "application/pkcs8"

	// KMimeApplicationPkcs8Encrypted
	//
	// English:
	//
	//  Application type 'pkcs8-encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs8-encrypted'
	KMimeApplicationPkcs8Encrypted Mime = "application/pkcs8-encrypted"

	// KMimeApplicationPkcs12
	//
	// English:
	//
	//  Application type 'pkcs12'
	//
	// Português:
	//
	//  Aplicação tipo 'pkcs12'
	KMimeApplicationPkcs12 Mime = "application/pkcs12"

	// KMimeApplicationPkixAttrCert
	//
	// English:
	//
	//  Application type 'pkix-attr-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-attr-cert'
	KMimeApplicationPkixAttrCert Mime = "application/pkix-attr-cert"

	// KMimeApplicationPkixCert
	//
	// English:
	//
	//  Application type 'pkix-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-cert'
	KMimeApplicationPkixCert Mime = "application/pkix-cert"

	// KMimeApplicationPkixCrl
	//
	// English:
	//
	//  Application type 'pkix-crl'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-crl'
	KMimeApplicationPkixCrl Mime = "application/pkix-crl"

	// KMimeApplicationPkixPkipath
	//
	// English:
	//
	//  Application type 'pkix-pkipath'
	//
	// Português:
	//
	//  Aplicação tipo 'pkix-pkipath'
	KMimeApplicationPkixPkipath Mime = "application/pkix-pkipath"

	// KMimeApplicationPkixcmp
	//
	// English:
	//
	//  Application type 'pkixcmp'
	//
	// Português:
	//
	//  Aplicação tipo 'pkixcmp'
	KMimeApplicationPkixcmp Mime = "application/pkixcmp"

	// KMimeApplicationPlsXml
	//
	// English:
	//
	//  Application type 'pls+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pls+xml'
	KMimeApplicationPlsXml Mime = "application/pls+xml"

	// KMimeApplicationPocSettingsXml
	//
	// English:
	//
	//  Application type 'poc-settings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'poc-settings+xml'
	KMimeApplicationPocSettingsXml Mime = "application/poc-settings+xml"

	// KMimeApplicationPostscript
	//
	// English:
	//
	//  Application type 'postscript'
	//
	// Português:
	//
	//  Aplicação tipo 'postscript'
	KMimeApplicationPostscript Mime = "application/postscript"

	// KMimeApplicationPpspTrackerJson
	//
	// English:
	//
	//  Application type 'ppsp-tracker+json'
	//
	// Português:
	//
	//  Aplicação tipo 'ppsp-tracker+json'
	KMimeApplicationPpspTrackerJson Mime = "application/ppsp-tracker+json"

	// KMimeApplicationProblemJson
	//
	// English:
	//
	//  Application type 'problem+json'
	//
	// Português:
	//
	//  Aplicação tipo 'problem+json'
	KMimeApplicationProblemJson Mime = "application/problem+json"

	// KMimeApplicationProblemXml
	//
	// English:
	//
	//  Application type 'problem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'problem+xml'
	KMimeApplicationProblemXml Mime = "application/problem+xml"

	// KMimeApplicationProvenanceXml
	//
	// English:
	//
	//  Application type 'provenance+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'provenance+xml'
	KMimeApplicationProvenanceXml Mime = "application/provenance+xml"

	// KMimeApplicationPrsAlvestrandTitraxSheet
	//
	// English:
	//
	//  Application type 'prs.alvestrand.titrax-sheet'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.alvestrand.titrax-sheet'
	KMimeApplicationPrsAlvestrandTitraxSheet Mime = "application/prs.alvestrand.titrax-sheet"

	// KMimeApplicationPrsCww
	//
	// English:
	//
	//  Application type 'prs.cww'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.cww'
	KMimeApplicationPrsCww Mime = "application/prs.cww"

	// KMimeApplicationPrsCyn
	//
	// English:
	//
	//  Application type 'prs.cyn'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.cyn'
	KMimeApplicationPrsCyn Mime = "application/prs.cyn"

	// KMimeApplicationPrsHpubZip
	//
	// English:
	//
	//  Application type 'prs.hpub+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.hpub+zip'
	KMimeApplicationPrsHpubZip Mime = "application/prs.hpub+zip"

	// KMimeApplicationPrsNprend
	//
	// English:
	//
	//  Application type 'prs.nprend'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.nprend'
	KMimeApplicationPrsNprend Mime = "application/prs.nprend"

	// KMimeApplicationPrsPlucker
	//
	// English:
	//
	//  Application type 'prs.plucker'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.plucker'
	KMimeApplicationPrsPlucker Mime = "application/prs.plucker"

	// KMimeApplicationPrsRdfXmlCrypt
	//
	// English:
	//
	//  Application type 'prs.rdf-xml-crypt'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.rdf-xml-crypt'
	KMimeApplicationPrsRdfXmlCrypt Mime = "application/prs.rdf-xml-crypt"

	// KMimeApplicationPrsXsfXml
	//
	// English:
	//
	//  Application type 'prs.xsf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'prs.xsf+xml'
	KMimeApplicationPrsXsfXml Mime = "application/prs.xsf+xml"

	// KMimeApplicationPskcXml
	//
	// English:
	//
	//  Application type 'pskc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'pskc+xml'
	KMimeApplicationPskcXml Mime = "application/pskc+xml"

	// KMimeApplicationPvdJson
	//
	// English:
	//
	//  Application type 'pvd+json'
	//
	// Português:
	//
	//  Aplicação tipo 'pvd+json'
	KMimeApplicationPvdJson Mime = "application/pvd+json"

	// KMimeApplicationRdfXml
	//
	// English:
	//
	//  Application type 'rdf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rdf+xml'
	KMimeApplicationRdfXml Mime = "application/rdf+xml"

	// KMimeApplicationRouteApdXml
	//
	// English:
	//
	//  Application type 'route-apd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'route-apd+xml'
	KMimeApplicationRouteApdXml Mime = "application/route-apd+xml"

	// KMimeApplicationRouteSTsidXml
	//
	// English:
	//
	//  Application type 'route-s-tsid+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'route-s-tsid+xml'
	KMimeApplicationRouteSTsidXml Mime = "application/route-s-tsid+xml"

	// KMimeApplicationRouteUsdXml
	//
	// English:
	//
	//  Application type 'route-usd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'route-usd+xml'
	KMimeApplicationRouteUsdXml Mime = "application/route-usd+xml"

	// KMimeApplicationQSIG
	//
	// English:
	//
	//  Application type 'QSIG'
	//
	// Português:
	//
	//  Aplicação tipo 'QSIG'
	KMimeApplicationQSIG Mime = "application/QSIG"

	// KMimeApplicationRaptorfec
	//
	// English:
	//
	//  Application type 'raptorfec'
	//
	// Português:
	//
	//  Aplicação tipo 'raptorfec'
	KMimeApplicationRaptorfec Mime = "application/raptorfec"

	// KMimeApplicationRdapJson
	//
	// English:
	//
	//  Application type 'rdap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'rdap+json'
	KMimeApplicationRdapJson Mime = "application/rdap+json"

	// KMimeApplicationReginfoXml
	//
	// English:
	//
	//  Application type 'reginfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'reginfo+xml'
	KMimeApplicationReginfoXml Mime = "application/reginfo+xml"

	// KMimeApplicationRelaxNgCompactSyntax
	//
	// English:
	//
	//  Application type 'relax-ng-compact-syntax'
	//
	// Português:
	//
	//  Aplicação tipo 'relax-ng-compact-syntax'
	KMimeApplicationRelaxNgCompactSyntax Mime = "application/relax-ng-compact-syntax"

	// KMimeApplicationRemotePrinting
	//
	// English:
	//
	//  Application type 'remote-printing'
	//
	// Português:
	//
	//  Aplicação tipo 'remote-printing'
	KMimeApplicationRemotePrinting Mime = "application/remote-printing"

	// KMimeApplicationReputonJson
	//
	// English:
	//
	//  Application type 'reputon+json'
	//
	// Português:
	//
	//  Aplicação tipo 'reputon+json'
	KMimeApplicationReputonJson Mime = "application/reputon+json"

	// KMimeApplicationResourceListsDiffXml
	//
	// English:
	//
	//  Application type 'resource-lists-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'resource-lists-diff+xml'
	KMimeApplicationResourceListsDiffXml Mime = "application/resource-lists-diff+xml"

	// KMimeApplicationResourceListsXml
	//
	// English:
	//
	//  Application type 'resource-lists+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'resource-lists+xml'
	KMimeApplicationResourceListsXml Mime = "application/resource-lists+xml"

	// KMimeApplicationRfcXml
	//
	// English:
	//
	//  Application type 'rfc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rfc+xml'
	KMimeApplicationRfcXml Mime = "application/rfc+xml"

	// KMimeApplicationRiscos
	//
	// English:
	//
	//  Application type 'riscos'
	//
	// Português:
	//
	//  Aplicação tipo 'riscos'
	KMimeApplicationRiscos Mime = "application/riscos"

	// KMimeApplicationRlmiXml
	//
	// English:
	//
	//  Application type 'rlmi+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rlmi+xml'
	KMimeApplicationRlmiXml Mime = "application/rlmi+xml"

	// KMimeApplicationRlsServicesXml
	//
	// English:
	//
	//  Application type 'rls-services+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'rls-services+xml'
	KMimeApplicationRlsServicesXml Mime = "application/rls-services+xml"

	// KMimeApplicationRpkiGhostbusters
	//
	// English:
	//
	//  Application type 'rpki-ghostbusters'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-ghostbusters'
	KMimeApplicationRpkiGhostbusters Mime = "application/rpki-ghostbusters"

	// KMimeApplicationRpkiManifest
	//
	// English:
	//
	//  Application type 'rpki-manifest'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-manifest'
	KMimeApplicationRpkiManifest Mime = "application/rpki-manifest"

	// KMimeApplicationRpkiPublication
	//
	// English:
	//
	//  Application type 'rpki-publication'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-publication'
	KMimeApplicationRpkiPublication Mime = "application/rpki-publication"

	// KMimeApplicationRpkiRoa
	//
	// English:
	//
	//  Application type 'rpki-roa'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-roa'
	KMimeApplicationRpkiRoa Mime = "application/rpki-roa"

	// KMimeApplicationRpkiUpdown
	//
	// English:
	//
	//  Application type 'rpki-updown'
	//
	// Português:
	//
	//  Aplicação tipo 'rpki-updown'
	KMimeApplicationRpkiUpdown Mime = "application/rpki-updown"

	// KMimeApplicationRtf
	//
	// English:
	//
	//  Application type 'rtf'
	//
	// Português:
	//
	//  Aplicação tipo 'rtf'
	KMimeApplicationRtf Mime = "application/rtf"

	// KMimeApplicationRtploopback
	//
	// English:
	//
	//  Application type 'rtploopback'
	//
	// Português:
	//
	//  Aplicação tipo 'rtploopback'
	KMimeApplicationRtploopback Mime = "application/rtploopback"

	// KMimeApplicationRtx
	//
	// English:
	//
	//  Application type 'rtx'
	//
	// Português:
	//
	//  Aplicação tipo 'rtx'
	KMimeApplicationRtx Mime = "application/rtx"

	// KMimeApplicationSamlassertionXml
	//
	// English:
	//
	//  Application type 'samlassertion+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'samlassertion+xml'
	KMimeApplicationSamlassertionXml Mime = "application/samlassertion+xml"

	// KMimeApplicationSamlmetadataXml
	//
	// English:
	//
	//  Application type 'samlmetadata+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'samlmetadata+xml'
	KMimeApplicationSamlmetadataXml Mime = "application/samlmetadata+xml"

	// KMimeApplicationSarifExternalPropertiesJson
	//
	// English:
	//
	//  Application type 'sarif-external-properties+json'
	//
	// Português:
	//
	//  Aplicação tipo 'sarif-external-properties+json'
	KMimeApplicationSarifExternalPropertiesJson Mime = "application/sarif-external-properties+json"

	// KMimeApplicationSarifJson
	//
	// English:
	//
	//  Application type 'sarif+json'
	//
	// Português:
	//
	//  Aplicação tipo 'sarif+json'
	KMimeApplicationSarifJson Mime = "application/sarif+json"

	// KMimeApplicationSbe
	//
	// English:
	//
	//  Application type 'sbe'
	//
	// Português:
	//
	//  Aplicação tipo 'sbe'
	KMimeApplicationSbe Mime = "application/sbe"

	// KMimeApplicationSbmlXml
	//
	// English:
	//
	//  Application type 'sbml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sbml+xml'
	KMimeApplicationSbmlXml Mime = "application/sbml+xml"

	// KMimeApplicationScaipXml
	//
	// English:
	//
	//  Application type 'scaip+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'scaip+xml'
	KMimeApplicationScaipXml Mime = "application/scaip+xml"

	// KMimeApplicationScimJson
	//
	// English:
	//
	//  Application type 'scim+json'
	//
	// Português:
	//
	//  Aplicação tipo 'scim+json'
	KMimeApplicationScimJson Mime = "application/scim+json"

	// KMimeApplicationScvpCvRequest
	//
	// English:
	//
	//  Application type 'scvp-cv-request'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-cv-request'
	KMimeApplicationScvpCvRequest Mime = "application/scvp-cv-request"

	// KMimeApplicationScvpCvResponse
	//
	// English:
	//
	//  Application type 'scvp-cv-response'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-cv-response'
	KMimeApplicationScvpCvResponse Mime = "application/scvp-cv-response"

	// KMimeApplicationScvpVpRequest
	//
	// English:
	//
	//  Application type 'scvp-vp-request'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-vp-request'
	KMimeApplicationScvpVpRequest Mime = "application/scvp-vp-request"

	// KMimeApplicationScvpVpResponse
	//
	// English:
	//
	//  Application type 'scvp-vp-response'
	//
	// Português:
	//
	//  Aplicação tipo 'scvp-vp-response'
	KMimeApplicationScvpVpResponse Mime = "application/scvp-vp-response"

	// KMimeApplicationSdp
	//
	// English:
	//
	//  Application type 'sdp'
	//
	// Português:
	//
	//  Aplicação tipo 'sdp'
	KMimeApplicationSdp Mime = "application/sdp"

	// KMimeApplicationSeceventJwt
	//
	// English:
	//
	//  Application type 'secevent+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'secevent+jwt'
	KMimeApplicationSeceventJwt Mime = "application/secevent+jwt"

	// KMimeApplicationSenmlEtchCbor
	//
	// English:
	//
	//  Application type 'senml-etch+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'senml-etch+cbor'
	KMimeApplicationSenmlEtchCbor Mime = "application/senml-etch+cbor"

	// KMimeApplicationSenmlEtchJson
	//
	// English:
	//
	//  Application type 'senml-etch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'senml-etch+json'
	KMimeApplicationSenmlEtchJson Mime = "application/senml-etch+json"

	// KMimeApplicationSenmlExi
	//
	// English:
	//
	//  Application type 'senml-exi'
	//
	// Português:
	//
	//  Aplicação tipo 'senml-exi'
	KMimeApplicationSenmlExi Mime = "application/senml-exi"

	// KMimeApplicationSenmlCbor
	//
	// English:
	//
	//  Application type 'senml+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'senml+cbor'
	KMimeApplicationSenmlCbor Mime = "application/senml+cbor"

	// KMimeApplicationSenmlJson
	//
	// English:
	//
	//  Application type 'senml+json'
	//
	// Português:
	//
	//  Aplicação tipo 'senml+json'
	KMimeApplicationSenmlJson Mime = "application/senml+json"

	// KMimeApplicationSenmlXml
	//
	// English:
	//
	//  Application type 'senml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'senml+xml'
	KMimeApplicationSenmlXml Mime = "application/senml+xml"

	// KMimeApplicationSensmlExi
	//
	// English:
	//
	//  Application type 'sensml-exi'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml-exi'
	KMimeApplicationSensmlExi Mime = "application/sensml-exi"

	// KMimeApplicationSensmlCbor
	//
	// English:
	//
	//  Application type 'sensml+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml+cbor'
	KMimeApplicationSensmlCbor Mime = "application/sensml+cbor"

	// KMimeApplicationSensmlJson
	//
	// English:
	//
	//  Application type 'sensml+json'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml+json'
	KMimeApplicationSensmlJson Mime = "application/sensml+json"

	// KMimeApplicationSensmlXml
	//
	// English:
	//
	//  Application type 'sensml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sensml+xml'
	KMimeApplicationSensmlXml Mime = "application/sensml+xml"

	// KMimeApplicationSepExi
	//
	// English:
	//
	//  Application type 'sep-exi'
	//
	// Português:
	//
	//  Aplicação tipo 'sep-exi'
	KMimeApplicationSepExi Mime = "application/sep-exi"

	// KMimeApplicationSepXml
	//
	// English:
	//
	//  Application type 'sep+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sep+xml'
	KMimeApplicationSepXml Mime = "application/sep+xml"

	// KMimeApplicationSessionInfo
	//
	// English:
	//
	//  Application type 'session-info'
	//
	// Português:
	//
	//  Aplicação tipo 'session-info'
	KMimeApplicationSessionInfo Mime = "application/session-info"

	// KMimeApplicationSetPayment
	//
	// English:
	//
	//  Application type 'set-payment'
	//
	// Português:
	//
	//  Aplicação tipo 'set-payment'
	KMimeApplicationSetPayment Mime = "application/set-payment"

	// KMimeApplicationSetPaymentInitiation
	//
	// English:
	//
	//  Application type 'set-payment-initiation'
	//
	// Português:
	//
	//  Aplicação tipo 'set-payment-initiation'
	KMimeApplicationSetPaymentInitiation Mime = "application/set-payment-initiation"

	// KMimeApplicationSetRegistration
	//
	// English:
	//
	//  Application type 'set-registration'
	//
	// Português:
	//
	//  Aplicação tipo 'set-registration'
	KMimeApplicationSetRegistration Mime = "application/set-registration"

	// KMimeApplicationSetRegistrationInitiation
	//
	// English:
	//
	//  Application type 'set-registration-initiation'
	//
	// Português:
	//
	//  Aplicação tipo 'set-registration-initiation'
	KMimeApplicationSetRegistrationInitiation Mime = "application/set-registration-initiation"

	// KMimeApplicationSGML
	//
	// English:
	//
	//  Application type 'SGML'
	//
	// Português:
	//
	//  Aplicação tipo 'SGML'
	KMimeApplicationSGML Mime = "application/SGML"

	// KMimeApplicationSgmlOpenCatalog
	//
	// English:
	//
	//  Application type 'sgml-open-catalog'
	//
	// Português:
	//
	//  Aplicação tipo 'sgml-open-catalog'
	KMimeApplicationSgmlOpenCatalog Mime = "application/sgml-open-catalog"

	// KMimeApplicationShfXml
	//
	// English:
	//
	//  Application type 'shf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'shf+xml'
	KMimeApplicationShfXml Mime = "application/shf+xml"

	// KMimeApplicationSieve
	//
	// English:
	//
	//  Application type 'sieve'
	//
	// Português:
	//
	//  Aplicação tipo 'sieve'
	KMimeApplicationSieve Mime = "application/sieve"

	// KMimeApplicationSimpleFilterXml
	//
	// English:
	//
	//  Application type 'simple-filter+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'simple-filter+xml'
	KMimeApplicationSimpleFilterXml Mime = "application/simple-filter+xml"

	// KMimeApplicationSimpleMessageSummary
	//
	// English:
	//
	//  Application type 'simple-message-summary'
	//
	// Português:
	//
	//  Aplicação tipo 'simple-message-summary'
	KMimeApplicationSimpleMessageSummary Mime = "application/simple-message-summary"

	// KMimeApplicationSimpleSymbolContainer
	//
	// English:
	//
	//  Application type 'simpleSymbolContainer'
	//
	// Português:
	//
	//  Aplicação tipo 'simpleSymbolContainer'
	KMimeApplicationSimpleSymbolContainer Mime = "application/simpleSymbolContainer"

	// KMimeApplicationSipc
	//
	// English:
	//
	//  Application type 'sipc'
	//
	// Português:
	//
	//  Aplicação tipo 'sipc'
	KMimeApplicationSipc Mime = "application/sipc"

	// KMimeApplicationSlate
	//
	// English:
	//
	//  Application type 'slate'
	//
	// Português:
	//
	//  Aplicação tipo 'slate'
	KMimeApplicationSlate Mime = "application/slate"

	// KMimeApplicationSmil
	//
	// English:
	//
	//  Application type 'smil'
	//
	// Português:
	//
	//  Aplicação tipo 'smil'
	KMimeApplicationSmil Mime = "(OBSOLETED"

	// KMimeApplicationSmilXml
	//
	// English:
	//
	//  Application type 'smil+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'smil+xml'
	KMimeApplicationSmilXml Mime = "application/smil+xml"

	// KMimeApplicationSmpte336m
	//
	// English:
	//
	//  Application type 'smpte336m'
	//
	// Português:
	//
	//  Aplicação tipo 'smpte336m'
	KMimeApplicationSmpte336m Mime = "application/smpte336m"

	// KMimeApplicationSoapFastinfoset
	//
	// English:
	//
	//  Application type 'soap+fastinfoset'
	//
	// Português:
	//
	//  Aplicação tipo 'soap+fastinfoset'
	KMimeApplicationSoapFastinfoset Mime = "application/soap+fastinfoset"

	// KMimeApplicationSoapXml
	//
	// English:
	//
	//  Application type 'soap+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'soap+xml'
	KMimeApplicationSoapXml Mime = "application/soap+xml"

	// KMimeApplicationSparqlQuery
	//
	// English:
	//
	//  Application type 'sparql-query'
	//
	// Português:
	//
	//  Aplicação tipo 'sparql-query'
	KMimeApplicationSparqlQuery Mime = "application/sparql-query"

	// KMimeApplicationSpdxJson
	//
	// English:
	//
	//  Application type 'spdx+json'
	//
	// Português:
	//
	//  Aplicação tipo 'spdx+json'
	KMimeApplicationSpdxJson Mime = "application/spdx+json"

	// KMimeApplicationSparqlResultsXml
	//
	// English:
	//
	//  Application type 'sparql-results+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sparql-results+xml'
	KMimeApplicationSparqlResultsXml Mime = "application/sparql-results+xml"

	// KMimeApplicationSpiritsEventXml
	//
	// English:
	//
	//  Application type 'spirits-event+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'spirits-event+xml'
	KMimeApplicationSpiritsEventXml Mime = "application/spirits-event+xml"

	// KMimeApplicationSql
	//
	// English:
	//
	//  Application type 'sql'
	//
	// Português:
	//
	//  Aplicação tipo 'sql'
	KMimeApplicationSql Mime = "application/sql"

	// KMimeApplicationSrgs
	//
	// English:
	//
	//  Application type 'srgs'
	//
	// Português:
	//
	//  Aplicação tipo 'srgs'
	KMimeApplicationSrgs Mime = "application/srgs"

	// KMimeApplicationSrgsXml
	//
	// English:
	//
	//  Application type 'srgs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'srgs+xml'
	KMimeApplicationSrgsXml Mime = "application/srgs+xml"

	// KMimeApplicationSruXml
	//
	// English:
	//
	//  Application type 'sru+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'sru+xml'
	KMimeApplicationSruXml Mime = "application/sru+xml"

	// KMimeApplicationSsmlXml
	//
	// English:
	//
	//  Application type 'ssml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ssml+xml'
	KMimeApplicationSsmlXml Mime = "application/ssml+xml"

	// KMimeApplicationStixJson
	//
	// English:
	//
	//  Application type 'stix+json'
	//
	// Português:
	//
	//  Aplicação tipo 'stix+json'
	KMimeApplicationStixJson Mime = "application/stix+json"

	// KMimeApplicationSwidXml
	//
	// English:
	//
	//  Application type 'swid+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'swid+xml'
	KMimeApplicationSwidXml Mime = "application/swid+xml"

	// KMimeApplicationTampApexUpdate
	//
	// English:
	//
	//  Application type 'tamp-apex-update'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-apex-update'
	KMimeApplicationTampApexUpdate Mime = "application/tamp-apex-update"

	// KMimeApplicationTampApexUpdateConfirm
	//
	// English:
	//
	//  Application type 'tamp-apex-update-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-apex-update-confirm'
	KMimeApplicationTampApexUpdateConfirm Mime = "application/tamp-apex-update-confirm"

	// KMimeApplicationTampCommunityUpdate
	//
	// English:
	//
	//  Application type 'tamp-community-update'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-community-update'
	KMimeApplicationTampCommunityUpdate Mime = "application/tamp-community-update"

	// KMimeApplicationTampCommunityUpdateConfirm
	//
	// English:
	//
	//  Application type 'tamp-community-update-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-community-update-confirm'
	KMimeApplicationTampCommunityUpdateConfirm Mime = "application/tamp-community-update-confirm"

	// KMimeApplicationTampError
	//
	// English:
	//
	//  Application type 'tamp-error'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-error'
	KMimeApplicationTampError Mime = "application/tamp-error"

	// KMimeApplicationTampSequenceAdjust
	//
	// English:
	//
	//  Application type 'tamp-sequence-adjust'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-sequence-adjust'
	KMimeApplicationTampSequenceAdjust Mime = "application/tamp-sequence-adjust"

	// KMimeApplicationTampSequenceAdjustConfirm
	//
	// English:
	//
	//  Application type 'tamp-sequence-adjust-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-sequence-adjust-confirm'
	KMimeApplicationTampSequenceAdjustConfirm Mime = "application/tamp-sequence-adjust-confirm"

	// KMimeApplicationTampStatusQuery
	//
	// English:
	//
	//  Application type 'tamp-status-query'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-status-query'
	KMimeApplicationTampStatusQuery Mime = "application/tamp-status-query"

	// KMimeApplicationTampStatusResponse
	//
	// English:
	//
	//  Application type 'tamp-status-response'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-status-response'
	KMimeApplicationTampStatusResponse Mime = "application/tamp-status-response"

	// KMimeApplicationTampUpdate
	//
	// English:
	//
	//  Application type 'tamp-update'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-update'
	KMimeApplicationTampUpdate Mime = "application/tamp-update"

	// KMimeApplicationTampUpdateConfirm
	//
	// English:
	//
	//  Application type 'tamp-update-confirm'
	//
	// Português:
	//
	//  Aplicação tipo 'tamp-update-confirm'
	KMimeApplicationTampUpdateConfirm Mime = "application/tamp-update-confirm"

	// KMimeApplicationTaxiiJson
	//
	// English:
	//
	//  Application type 'taxii+json'
	//
	// Português:
	//
	//  Aplicação tipo 'taxii+json'
	KMimeApplicationTaxiiJson Mime = "application/taxii+json"

	// KMimeApplicationTdJson
	//
	// English:
	//
	//  Application type 'td+json'
	//
	// Português:
	//
	//  Aplicação tipo 'td+json'
	KMimeApplicationTdJson Mime = "application/td+json"

	// KMimeApplicationTeiXml
	//
	// English:
	//
	//  Application type 'tei+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'tei+xml'
	KMimeApplicationTeiXml Mime = "application/tei+xml"

	// KMimeApplicationTETRAISI
	//
	// English:
	//
	//  Application type 'TETRA_ISI'
	//
	// Português:
	//
	//  Aplicação tipo 'TETRA_ISI'
	KMimeApplicationTETRAISI Mime = "application/TETRA_ISI"

	// KMimeApplicationThraudXml
	//
	// English:
	//
	//  Application type 'thraud+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'thraud+xml'
	KMimeApplicationThraudXml Mime = "application/thraud+xml"

	// KMimeApplicationTimestampQuery
	//
	// English:
	//
	//  Application type 'timestamp-query'
	//
	// Português:
	//
	//  Aplicação tipo 'timestamp-query'
	KMimeApplicationTimestampQuery Mime = "application/timestamp-query"

	// KMimeApplicationTimestampReply
	//
	// English:
	//
	//  Application type 'timestamp-reply'
	//
	// Português:
	//
	//  Aplicação tipo 'timestamp-reply'
	KMimeApplicationTimestampReply Mime = "application/timestamp-reply"

	// KMimeApplicationTimestampedData
	//
	// English:
	//
	//  Application type 'timestamped-data'
	//
	// Português:
	//
	//  Aplicação tipo 'timestamped-data'
	KMimeApplicationTimestampedData Mime = "application/timestamped-data"

	// KMimeApplicationTlsrptGzip
	//
	// English:
	//
	//  Application type 'tlsrpt+gzip'
	//
	// Português:
	//
	//  Aplicação tipo 'tlsrpt+gzip'
	KMimeApplicationTlsrptGzip Mime = "application/tlsrpt+gzip"

	// KMimeApplicationTlsrptJson
	//
	// English:
	//
	//  Application type 'tlsrpt+json'
	//
	// Português:
	//
	//  Aplicação tipo 'tlsrpt+json'
	KMimeApplicationTlsrptJson Mime = "application/tlsrpt+json"

	// KMimeApplicationTnauthlist
	//
	// English:
	//
	//  Application type 'tnauthlist'
	//
	// Português:
	//
	//  Aplicação tipo 'tnauthlist'
	KMimeApplicationTnauthlist Mime = "application/tnauthlist"

	// KMimeApplicationTokenIntrospectionJwt
	//
	// English:
	//
	//  Application type 'token-introspection+jwt'
	//
	// Português:
	//
	//  Aplicação tipo 'token-introspection+jwt'
	KMimeApplicationTokenIntrospectionJwt Mime = "application/token-introspection+jwt"

	// KMimeApplicationTrickleIceSdpfrag
	//
	// English:
	//
	//  Application type 'trickle-ice-sdpfrag'
	//
	// Português:
	//
	//  Aplicação tipo 'trickle-ice-sdpfrag'
	KMimeApplicationTrickleIceSdpfrag Mime = "application/trickle-ice-sdpfrag"

	// KMimeApplicationTrig
	//
	// English:
	//
	//  Application type 'trig'
	//
	// Português:
	//
	//  Aplicação tipo 'trig'
	KMimeApplicationTrig Mime = "application/trig"

	// KMimeApplicationTtmlXml
	//
	// English:
	//
	//  Application type 'ttml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'ttml+xml'
	KMimeApplicationTtmlXml Mime = "application/ttml+xml"

	// KMimeApplicationTveTrigger
	//
	// English:
	//
	//  Application type 'tve-trigger'
	//
	// Português:
	//
	//  Aplicação tipo 'tve-trigger'
	KMimeApplicationTveTrigger Mime = "application/tve-trigger"

	// KMimeApplicationTzif
	//
	// English:
	//
	//  Application type 'tzif'
	//
	// Português:
	//
	//  Aplicação tipo 'tzif'
	KMimeApplicationTzif Mime = "application/tzif"

	// KMimeApplicationTzifLeap
	//
	// English:
	//
	//  Application type 'tzif-leap'
	//
	// Português:
	//
	//  Aplicação tipo 'tzif-leap'
	KMimeApplicationTzifLeap Mime = "application/tzif-leap"

	// KMimeApplicationUlpfec
	//
	// English:
	//
	//  Application type 'ulpfec'
	//
	// Português:
	//
	//  Aplicação tipo 'ulpfec'
	KMimeApplicationUlpfec Mime = "application/ulpfec"

	// KMimeApplicationUrcGrpsheetXml
	//
	// English:
	//
	//  Application type 'urc-grpsheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-grpsheet+xml'
	KMimeApplicationUrcGrpsheetXml Mime = "application/urc-grpsheet+xml"

	// KMimeApplicationUrcRessheetXml
	//
	// English:
	//
	//  Application type 'urc-ressheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-ressheet+xml'
	KMimeApplicationUrcRessheetXml Mime = "application/urc-ressheet+xml"

	// KMimeApplicationUrcTargetdescXml
	//
	// English:
	//
	//  Application type 'urc-targetdesc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-targetdesc+xml'
	KMimeApplicationUrcTargetdescXml Mime = "application/urc-targetdesc+xml"

	// KMimeApplicationUrcUisocketdescXml
	//
	// English:
	//
	//  Application type 'urc-uisocketdesc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'urc-uisocketdesc+xml'
	KMimeApplicationUrcUisocketdescXml Mime = "application/urc-uisocketdesc+xml"

	// KMimeApplicationVcardJson
	//
	// English:
	//
	//  Application type 'vcard+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vcard+json'
	KMimeApplicationVcardJson Mime = "application/vcard+json"

	// KMimeApplicationVcardXml
	//
	// English:
	//
	//  Application type 'vcard+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vcard+xml'
	KMimeApplicationVcardXml Mime = "application/vcard+xml"

	// KMimeApplicationVemmi
	//
	// English:
	//
	//  Application type 'vemmi'
	//
	// Português:
	//
	//  Aplicação tipo 'vemmi'
	KMimeApplicationVemmi Mime = "application/vemmi"

	// KMimeApplicationVnd1000mindsDecisionModelXml
	//
	// English:
	//
	//  Application type 'vnd.1000minds.decision-model+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.1000minds.decision-model+xml'
	KMimeApplicationVnd1000mindsDecisionModelXml Mime = "application/vnd.1000minds.decision-model+xml"

	// KMimeApplicationVnd3gpp5gnas
	//
	// English:
	//
	//  Application type 'vnd.3gpp.5gnas'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.5gnas'
	KMimeApplicationVnd3gpp5gnas Mime = "application/vnd.3gpp.5gnas"

	// KMimeApplicationVnd3gppAccessTransferEventsXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.access-transfer-events+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.access-transfer-events+xml'
	KMimeApplicationVnd3gppAccessTransferEventsXml Mime = "application/vnd.3gpp.access-transfer-events+xml"

	// KMimeApplicationVnd3gppBsfXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.bsf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.bsf+xml'
	KMimeApplicationVnd3gppBsfXml Mime = "application/vnd.3gpp.bsf+xml"

	// KMimeApplicationVnd3gppGMOPXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.GMOP+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.GMOP+xml'
	KMimeApplicationVnd3gppGMOPXml Mime = "application/vnd.3gpp.GMOP+xml"

	// KMimeApplicationVnd3gppGtpc
	//
	// English:
	//
	//  Application type 'vnd.3gpp.gtpc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.gtpc'
	KMimeApplicationVnd3gppGtpc Mime = "application/vnd.3gpp.gtpc"

	// KMimeApplicationVnd3gppInterworkingData
	//
	// English:
	//
	//  Application type 'vnd.3gpp.interworking-data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.interworking-data'
	KMimeApplicationVnd3gppInterworkingData Mime = "application/vnd.3gpp.interworking-data"

	// KMimeApplicationVnd3gppLpp
	//
	// English:
	//
	//  Application type 'vnd.3gpp.lpp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.lpp'
	KMimeApplicationVnd3gppLpp Mime = "application/vnd.3gpp.lpp"

	// KMimeApplicationVnd3gppMcSignallingEar
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mc-signalling-ear'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mc-signalling-ear'
	KMimeApplicationVnd3gppMcSignallingEar Mime = "application/vnd.3gpp.mc-signalling-ear"

	// KMimeApplicationVnd3gppMcdataAffiliationCommandXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-affiliation-command+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-affiliation-command+xml'
	KMimeApplicationVnd3gppMcdataAffiliationCommandXml Mime = "application/vnd.3gpp.mcdata-affiliation-command+xml"

	// KMimeApplicationVnd3gppMcdataInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-info+xml'
	KMimeApplicationVnd3gppMcdataInfoXml Mime = "application/vnd.3gpp.mcdata-info+xml"

	// KMimeApplicationVnd3gppMcdataMsgstoreCtrlRequestXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-msgstore-ctrl-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-msgstore-ctrl-request+xml'
	KMimeApplicationVnd3gppMcdataMsgstoreCtrlRequestXml Mime = "application/vnd.3gpp.mcdata-msgstore-ctrl-request+xml"

	// KMimeApplicationVnd3gppMcdataPayload
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-payload'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-payload'
	KMimeApplicationVnd3gppMcdataPayload Mime = "application/vnd.3gpp.mcdata-payload"

	// KMimeApplicationVnd3gppMcdataRegroupXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-regroup+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-regroup+xml'
	KMimeApplicationVnd3gppMcdataRegroupXml Mime = "application/vnd.3gpp.mcdata-regroup+xml"

	// KMimeApplicationVnd3gppMcdataServiceConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-service-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-service-config+xml'
	KMimeApplicationVnd3gppMcdataServiceConfigXml Mime = "application/vnd.3gpp.mcdata-service-config+xml"

	// KMimeApplicationVnd3gppMcdataSignalling
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-signalling'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-signalling'
	KMimeApplicationVnd3gppMcdataSignalling Mime = "application/vnd.3gpp.mcdata-signalling"

	// KMimeApplicationVnd3gppMcdataUeConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-ue-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-ue-config+xml'
	KMimeApplicationVnd3gppMcdataUeConfigXml Mime = "application/vnd.3gpp.mcdata-ue-config+xml"

	// KMimeApplicationVnd3gppMcdataUserProfileXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcdata-user-profile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcdata-user-profile+xml'
	KMimeApplicationVnd3gppMcdataUserProfileXml Mime = "application/vnd.3gpp.mcdata-user-profile+xml"

	// KMimeApplicationVnd3gppMcpttAffiliationCommandXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-affiliation-command+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-affiliation-command+xml'
	KMimeApplicationVnd3gppMcpttAffiliationCommandXml Mime = "application/vnd.3gpp.mcptt-affiliation-command+xml"

	// KMimeApplicationVnd3gppMcpttFloorRequestXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-floor-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-floor-request+xml'
	KMimeApplicationVnd3gppMcpttFloorRequestXml Mime = "application/vnd.3gpp.mcptt-floor-request+xml"

	// KMimeApplicationVnd3gppMcpttInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-info+xml'
	KMimeApplicationVnd3gppMcpttInfoXml Mime = "application/vnd.3gpp.mcptt-info+xml"

	// KMimeApplicationVnd3gppMcpttLocationInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-location-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-location-info+xml'
	KMimeApplicationVnd3gppMcpttLocationInfoXml Mime = "application/vnd.3gpp.mcptt-location-info+xml"

	// KMimeApplicationVnd3gppMcpttMbmsUsageInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-mbms-usage-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-mbms-usage-info+xml'
	KMimeApplicationVnd3gppMcpttMbmsUsageInfoXml Mime = "application/vnd.3gpp.mcptt-mbms-usage-info+xml"

	// KMimeApplicationVnd3gppMcpttServiceConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-service-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-service-config+xml'
	KMimeApplicationVnd3gppMcpttServiceConfigXml Mime = "application/vnd.3gpp.mcptt-service-config+xml"

	// KMimeApplicationVnd3gppMcpttSignedXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-signed+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-signed+xml'
	KMimeApplicationVnd3gppMcpttSignedXml Mime = "application/vnd.3gpp.mcptt-signed+xml"

	// KMimeApplicationVnd3gppMcpttUeConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-ue-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-ue-config+xml'
	KMimeApplicationVnd3gppMcpttUeConfigXml Mime = "application/vnd.3gpp.mcptt-ue-config+xml"

	// KMimeApplicationVnd3gppMcpttUeInitConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-ue-init-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-ue-init-config+xml'
	KMimeApplicationVnd3gppMcpttUeInitConfigXml Mime = "application/vnd.3gpp.mcptt-ue-init-config+xml"

	// KMimeApplicationVnd3gppMcpttUserProfileXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcptt-user-profile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcptt-user-profile+xml'
	KMimeApplicationVnd3gppMcpttUserProfileXml Mime = "application/vnd.3gpp.mcptt-user-profile+xml"

	// KMimeApplicationVnd3gppMcvideoAffiliationCommandXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-affiliation-command+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-affiliation-command+xml'
	KMimeApplicationVnd3gppMcvideoAffiliationCommandXml Mime = "application/vnd.3gpp.mcvideo-affiliation-command+xml"

	// KMimeApplicationVnd3gppMcvideoAffiliationInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-affiliation-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-affiliation-info+xml'
	KMimeApplicationVnd3gppMcvideoAffiliationInfoXml Mime = "(OBSOLETED"

	// KMimeApplicationVnd3gppMcvideoInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-info+xml'
	KMimeApplicationVnd3gppMcvideoInfoXml Mime = "application/vnd.3gpp.mcvideo-info+xml"

	// KMimeApplicationVnd3gppMcvideoLocationInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-location-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-location-info+xml'
	KMimeApplicationVnd3gppMcvideoLocationInfoXml Mime = "application/vnd.3gpp.mcvideo-location-info+xml"

	// KMimeApplicationVnd3gppMcvideoMbmsUsageInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-mbms-usage-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-mbms-usage-info+xml'
	KMimeApplicationVnd3gppMcvideoMbmsUsageInfoXml Mime = "application/vnd.3gpp.mcvideo-mbms-usage-info+xml"

	// KMimeApplicationVnd3gppMcvideoServiceConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-service-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-service-config+xml'
	KMimeApplicationVnd3gppMcvideoServiceConfigXml Mime = "application/vnd.3gpp.mcvideo-service-config+xml"

	// KMimeApplicationVnd3gppMcvideoTransmissionRequestXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-transmission-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-transmission-request+xml'
	KMimeApplicationVnd3gppMcvideoTransmissionRequestXml Mime = "application/vnd.3gpp.mcvideo-transmission-request+xml"

	// KMimeApplicationVnd3gppMcvideoUeConfigXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-ue-config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-ue-config+xml'
	KMimeApplicationVnd3gppMcvideoUeConfigXml Mime = "application/vnd.3gpp.mcvideo-ue-config+xml"

	// KMimeApplicationVnd3gppMcvideoUserProfileXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mcvideo-user-profile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mcvideo-user-profile+xml'
	KMimeApplicationVnd3gppMcvideoUserProfileXml Mime = "application/vnd.3gpp.mcvideo-user-profile+xml"

	// KMimeApplicationVnd3gppMidCallXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.mid-call+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.mid-call+xml'
	KMimeApplicationVnd3gppMidCallXml Mime = "application/vnd.3gpp.mid-call+xml"

	// KMimeApplicationVnd3gppNgap
	//
	// English:
	//
	//  Application type 'vnd.3gpp.ngap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.ngap'
	KMimeApplicationVnd3gppNgap Mime = "application/vnd.3gpp.ngap"

	// KMimeApplicationVnd3gppPfcp
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pfcp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pfcp'
	KMimeApplicationVnd3gppPfcp Mime = "application/vnd.3gpp.pfcp"

	// KMimeApplicationVnd3gppPicBwLarge
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pic-bw-large'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pic-bw-large'
	KMimeApplicationVnd3gppPicBwLarge Mime = "application/vnd.3gpp.pic-bw-large"

	// KMimeApplicationVnd3gppPicBwSmall
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pic-bw-small'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pic-bw-small'
	KMimeApplicationVnd3gppPicBwSmall Mime = "application/vnd.3gpp.pic-bw-small"

	// KMimeApplicationVnd3gppPicBwVar
	//
	// English:
	//
	//  Application type 'vnd.3gpp.pic-bw-var'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.pic-bw-var'
	KMimeApplicationVnd3gppPicBwVar Mime = "application/vnd.3gpp.pic-bw-var"

	// KMimeApplicationVnd3gppProsePc3chXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp-prose-pc3ch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp-prose-pc3ch+xml'
	KMimeApplicationVnd3gppProsePc3chXml Mime = "application/vnd.3gpp-prose-pc3ch+xml"

	// KMimeApplicationVnd3gppProseXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp-prose+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp-prose+xml'
	KMimeApplicationVnd3gppProseXml Mime = "application/vnd.3gpp-prose+xml"

	// KMimeApplicationVnd3gppS1ap
	//
	// English:
	//
	//  Application type 'vnd.3gpp.s1ap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.s1ap'
	KMimeApplicationVnd3gppS1ap Mime = "application/vnd.3gpp.s1ap"

	// KMimeApplicationVnd3gppSms
	//
	// English:
	//
	//  Application type 'vnd.3gpp.sms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.sms'
	KMimeApplicationVnd3gppSms Mime = "application/vnd.3gpp.sms"

	// KMimeApplicationVnd3gppSmsXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.sms+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.sms+xml'
	KMimeApplicationVnd3gppSmsXml Mime = "application/vnd.3gpp.sms+xml"

	// KMimeApplicationVnd3gppSrvccExtXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.srvcc-ext+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.srvcc-ext+xml'
	KMimeApplicationVnd3gppSrvccExtXml Mime = "application/vnd.3gpp.srvcc-ext+xml"

	// KMimeApplicationVnd3gppSRVCCInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.SRVCC-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.SRVCC-info+xml'
	KMimeApplicationVnd3gppSRVCCInfoXml Mime = "application/vnd.3gpp.SRVCC-info+xml"

	// KMimeApplicationVnd3gppStateAndEventInfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.state-and-event-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.state-and-event-info+xml'
	KMimeApplicationVnd3gppStateAndEventInfoXml Mime = "application/vnd.3gpp.state-and-event-info+xml"

	// KMimeApplicationVnd3gppUssdXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp.ussd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp.ussd+xml'
	KMimeApplicationVnd3gppUssdXml Mime = "application/vnd.3gpp.ussd+xml"

	// KMimeApplicationVnd3gppV2xLocalServiceInformation
	//
	// English:
	//
	//  Application type 'vnd.3gpp-v2x-local-service-information'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp-v2x-local-service-information'
	KMimeApplicationVnd3gppV2xLocalServiceInformation Mime = "application/vnd.3gpp-v2x-local-service-information"

	// KMimeApplicationVnd3gpp2BcmcsinfoXml
	//
	// English:
	//
	//  Application type 'vnd.3gpp2.bcmcsinfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp2.bcmcsinfo+xml'
	KMimeApplicationVnd3gpp2BcmcsinfoXml Mime = "application/vnd.3gpp2.bcmcsinfo+xml"

	// KMimeApplicationVnd3gpp2Sms
	//
	// English:
	//
	//  Application type 'vnd.3gpp2.sms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp2.sms'
	KMimeApplicationVnd3gpp2Sms Mime = "application/vnd.3gpp2.sms"

	// KMimeApplicationVnd3gpp2Tcap
	//
	// English:
	//
	//  Application type 'vnd.3gpp2.tcap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3gpp2.tcap'
	KMimeApplicationVnd3gpp2Tcap Mime = "application/vnd.3gpp2.tcap"

	// KMimeApplicationVnd3lightssoftwareImagescal
	//
	// English:
	//
	//  Application type 'vnd.3lightssoftware.imagescal'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3lightssoftware.imagescal'
	KMimeApplicationVnd3lightssoftwareImagescal Mime = "application/vnd.3lightssoftware.imagescal"

	// KMimeApplicationVnd3MPostItNotes
	//
	// English:
	//
	//  Application type 'vnd.3M.Post-it-Notes'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.3M.Post-it-Notes'
	KMimeApplicationVnd3MPostItNotes Mime = "application/vnd.3M.Post-it-Notes"

	// KMimeApplicationVndAccpacSimplyAso
	//
	// English:
	//
	//  Application type 'vnd.accpac.simply.aso'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.accpac.simply.aso'
	KMimeApplicationVndAccpacSimplyAso Mime = "application/vnd.accpac.simply.aso"

	// KMimeApplicationVndAccpacSimplyImp
	//
	// English:
	//
	//  Application type 'vnd.accpac.simply.imp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.accpac.simply.imp'
	KMimeApplicationVndAccpacSimplyImp Mime = "application/vnd.accpac.simply.imp"

	// KMimeApplicationVndAcucobol
	//
	// English:
	//
	//  Application type 'vnd.acucobol'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.acucobol'
	KMimeApplicationVndAcucobol Mime = "application/vnd.acucobol"

	// KMimeApplicationVndAcucorp
	//
	// English:
	//
	//  Application type 'vnd.acucorp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.acucorp'
	KMimeApplicationVndAcucorp Mime = "application/vnd.acucorp"

	// KMimeApplicationVndAdobeFlashMovie
	//
	// English:
	//
	//  Application type 'vnd.adobe.flash.movie'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.flash.movie'
	KMimeApplicationVndAdobeFlashMovie Mime = "application/vnd.adobe.flash.movie"

	// KMimeApplicationVndAdobeFormscentralFcdt
	//
	// English:
	//
	//  Application type 'vnd.adobe.formscentral.fcdt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.formscentral.fcdt'
	KMimeApplicationVndAdobeFormscentralFcdt Mime = "application/vnd.adobe.formscentral.fcdt"

	// KMimeApplicationVndAdobeFxp
	//
	// English:
	//
	//  Application type 'vnd.adobe.fxp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.fxp'
	KMimeApplicationVndAdobeFxp Mime = "application/vnd.adobe.fxp"

	// KMimeApplicationVndAdobePartialUpload
	//
	// English:
	//
	//  Application type 'vnd.adobe.partial-upload'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.partial-upload'
	KMimeApplicationVndAdobePartialUpload Mime = "application/vnd.adobe.partial-upload"

	// KMimeApplicationVndAdobeXdpXml
	//
	// English:
	//
	//  Application type 'vnd.adobe.xdp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.xdp+xml'
	KMimeApplicationVndAdobeXdpXml Mime = "application/vnd.adobe.xdp+xml"

	// KMimeApplicationVndAdobeXfdf
	//
	// English:
	//
	//  Application type 'vnd.adobe.xfdf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.adobe.xfdf'
	KMimeApplicationVndAdobeXfdf Mime = "application/vnd.adobe.xfdf"

	// KMimeApplicationVndAetherImp
	//
	// English:
	//
	//  Application type 'vnd.aether.imp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.aether.imp'
	KMimeApplicationVndAetherImp Mime = "application/vnd.aether.imp"

	// KMimeApplicationVndAfpcAfplinedata
	//
	// English:
	//
	//  Application type 'vnd.afpc.afplinedata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.afplinedata'
	KMimeApplicationVndAfpcAfplinedata Mime = "application/vnd.afpc.afplinedata"

	// KMimeApplicationVndAfpcAfplinedataPagedef
	//
	// English:
	//
	//  Application type 'vnd.afpc.afplinedata-pagedef'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.afplinedata-pagedef'
	KMimeApplicationVndAfpcAfplinedataPagedef Mime = "application/vnd.afpc.afplinedata-pagedef"

	// KMimeApplicationVndAfpcCmocaCmresource
	//
	// English:
	//
	//  Application type 'vnd.afpc.cmoca-cmresource'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.cmoca-cmresource'
	KMimeApplicationVndAfpcCmocaCmresource Mime = "application/vnd.afpc.cmoca-cmresource"

	// KMimeApplicationVndAfpcFocaCharset
	//
	// English:
	//
	//  Application type 'vnd.afpc.foca-charset'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.foca-charset'
	KMimeApplicationVndAfpcFocaCharset Mime = "application/vnd.afpc.foca-charset"

	// KMimeApplicationVndAfpcFocaCodedfont
	//
	// English:
	//
	//  Application type 'vnd.afpc.foca-codedfont'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.foca-codedfont'
	KMimeApplicationVndAfpcFocaCodedfont Mime = "application/vnd.afpc.foca-codedfont"

	// KMimeApplicationVndAfpcFocaCodepage
	//
	// English:
	//
	//  Application type 'vnd.afpc.foca-codepage'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.foca-codepage'
	KMimeApplicationVndAfpcFocaCodepage Mime = "application/vnd.afpc.foca-codepage"

	// KMimeApplicationVndAfpcModca
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca'
	KMimeApplicationVndAfpcModca Mime = "application/vnd.afpc.modca"

	// KMimeApplicationVndAfpcModcaCmtable
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-cmtable'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-cmtable'
	KMimeApplicationVndAfpcModcaCmtable Mime = "application/vnd.afpc.modca-cmtable"

	// KMimeApplicationVndAfpcModcaFormdef
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-formdef'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-formdef'
	KMimeApplicationVndAfpcModcaFormdef Mime = "application/vnd.afpc.modca-formdef"

	// KMimeApplicationVndAfpcModcaMediummap
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-mediummap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-mediummap'
	KMimeApplicationVndAfpcModcaMediummap Mime = "application/vnd.afpc.modca-mediummap"

	// KMimeApplicationVndAfpcModcaObjectcontainer
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-objectcontainer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-objectcontainer'
	KMimeApplicationVndAfpcModcaObjectcontainer Mime = "application/vnd.afpc.modca-objectcontainer"

	// KMimeApplicationVndAfpcModcaOverlay
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-overlay'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-overlay'
	KMimeApplicationVndAfpcModcaOverlay Mime = "application/vnd.afpc.modca-overlay"

	// KMimeApplicationVndAfpcModcaPagesegment
	//
	// English:
	//
	//  Application type 'vnd.afpc.modca-pagesegment'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.afpc.modca-pagesegment'
	KMimeApplicationVndAfpcModcaPagesegment Mime = "application/vnd.afpc.modca-pagesegment"

	// KMimeApplicationVndAge
	//
	// English:
	//
	//  Application type 'vnd.age'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.age'
	KMimeApplicationVndAge Mime = "application/vnd.age"

	// KMimeApplicationVndAhBarcode
	//
	// English:
	//
	//  Application type 'vnd.ah-barcode'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ah-barcode'
	KMimeApplicationVndAhBarcode Mime = "application/vnd.ah-barcode"

	// KMimeApplicationVndAheadSpace
	//
	// English:
	//
	//  Application type 'vnd.ahead.space'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ahead.space'
	KMimeApplicationVndAheadSpace Mime = "application/vnd.ahead.space"

	// KMimeApplicationVndAirzipFilesecureAzf
	//
	// English:
	//
	//  Application type 'vnd.airzip.filesecure.azf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.airzip.filesecure.azf'
	KMimeApplicationVndAirzipFilesecureAzf Mime = "application/vnd.airzip.filesecure.azf"

	// KMimeApplicationVndAirzipFilesecureAzs
	//
	// English:
	//
	//  Application type 'vnd.airzip.filesecure.azs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.airzip.filesecure.azs'
	KMimeApplicationVndAirzipFilesecureAzs Mime = "application/vnd.airzip.filesecure.azs"

	// KMimeApplicationVndAmadeusJson
	//
	// English:
	//
	//  Application type 'vnd.amadeus+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amadeus+json'
	KMimeApplicationVndAmadeusJson Mime = "application/vnd.amadeus+json"

	// KMimeApplicationVndAmazonMobi8Ebook
	//
	// English:
	//
	//  Application type 'vnd.amazon.mobi8-ebook'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amazon.mobi8-ebook'
	KMimeApplicationVndAmazonMobi8Ebook Mime = "application/vnd.amazon.mobi8-ebook"

	// KMimeApplicationVndAmericandynamicsAcc
	//
	// English:
	//
	//  Application type 'vnd.americandynamics.acc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.americandynamics.acc'
	KMimeApplicationVndAmericandynamicsAcc Mime = "application/vnd.americandynamics.acc"

	// KMimeApplicationVndAmigaAmi
	//
	// English:
	//
	//  Application type 'vnd.amiga.ami'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amiga.ami'
	KMimeApplicationVndAmigaAmi Mime = "application/vnd.amiga.ami"

	// KMimeApplicationVndAmundsenMazeXml
	//
	// English:
	//
	//  Application type 'vnd.amundsen.maze+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.amundsen.maze+xml'
	KMimeApplicationVndAmundsenMazeXml Mime = "application/vnd.amundsen.maze+xml"

	// KMimeApplicationVndAndroidOta
	//
	// English:
	//
	//  Application type 'vnd.android.ota'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.android.ota'
	KMimeApplicationVndAndroidOta Mime = "application/vnd.android.ota"

	// KMimeApplicationVndAnki
	//
	// English:
	//
	//  Application type 'vnd.anki'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.anki'
	KMimeApplicationVndAnki Mime = "application/vnd.anki"

	// KMimeApplicationVndAnserWebCertificateIssueInitiation
	//
	// English:
	//
	//  Application type 'vnd.anser-web-certificate-issue-initiation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.anser-web-certificate-issue-initiation'
	KMimeApplicationVndAnserWebCertificateIssueInitiation Mime = "application/vnd.anser-web-certificate-issue-initiation"

	// KMimeApplicationVndAntixGameComponent
	//
	// English:
	//
	//  Application type 'vnd.antix.game-component'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.antix.game-component'
	KMimeApplicationVndAntixGameComponent Mime = "application/vnd.antix.game-component"

	// KMimeApplicationVndApacheArrowFile
	//
	// English:
	//
	//  Application type 'vnd.apache.arrow.file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.arrow.file'
	KMimeApplicationVndApacheArrowFile Mime = "application/vnd.apache.arrow.file"

	// KMimeApplicationVndApacheArrowStream
	//
	// English:
	//
	//  Application type 'vnd.apache.arrow.stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.arrow.stream'
	KMimeApplicationVndApacheArrowStream Mime = "application/vnd.apache.arrow.stream"

	// KMimeApplicationVndApacheThriftBinary
	//
	// English:
	//
	//  Application type 'vnd.apache.thrift.binary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.thrift.binary'
	KMimeApplicationVndApacheThriftBinary Mime = "application/vnd.apache.thrift.binary"

	// KMimeApplicationVndApacheThriftCompact
	//
	// English:
	//
	//  Application type 'vnd.apache.thrift.compact'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.thrift.compact'
	KMimeApplicationVndApacheThriftCompact Mime = "application/vnd.apache.thrift.compact"

	// KMimeApplicationVndApacheThriftJson
	//
	// English:
	//
	//  Application type 'vnd.apache.thrift.json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apache.thrift.json'
	KMimeApplicationVndApacheThriftJson Mime = "application/vnd.apache.thrift.json"

	// KMimeApplicationVndApiJson
	//
	// English:
	//
	//  Application type 'vnd.api+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.api+json'
	KMimeApplicationVndApiJson Mime = "application/vnd.api+json"

	// KMimeApplicationVndAplextorWarrpJson
	//
	// English:
	//
	//  Application type 'vnd.aplextor.warrp+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.aplextor.warrp+json'
	KMimeApplicationVndAplextorWarrpJson Mime = "application/vnd.aplextor.warrp+json"

	// KMimeApplicationVndApothekendeReservationJson
	//
	// English:
	//
	//  Application type 'vnd.apothekende.reservation+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apothekende.reservation+json'
	KMimeApplicationVndApothekendeReservationJson Mime = "application/vnd.apothekende.reservation+json"

	// KMimeApplicationVndAppleInstallerXml
	//
	// English:
	//
	//  Application type 'vnd.apple.installer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.installer+xml'
	KMimeApplicationVndAppleInstallerXml Mime = "application/vnd.apple.installer+xml"

	// KMimeApplicationVndAppleKeynote
	//
	// English:
	//
	//  Application type 'vnd.apple.keynote'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.keynote'
	KMimeApplicationVndAppleKeynote Mime = "application/vnd.apple.keynote"

	// KMimeApplicationVndAppleMpegurl
	//
	// English:
	//
	//  Application type 'vnd.apple.mpegurl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.mpegurl'
	KMimeApplicationVndAppleMpegurl Mime = "application/vnd.apple.mpegurl"

	// KMimeApplicationVndAppleNumbers
	//
	// English:
	//
	//  Application type 'vnd.apple.numbers'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.numbers'
	KMimeApplicationVndAppleNumbers Mime = "application/vnd.apple.numbers"

	// KMimeApplicationVndApplePages
	//
	// English:
	//
	//  Application type 'vnd.apple.pages'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.apple.pages'
	KMimeApplicationVndApplePages Mime = "application/vnd.apple.pages"

	// KMimeApplicationVndArastraSwi
	//
	// English:
	//
	//  Application type 'vnd.arastra.swi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.arastra.swi'
	KMimeApplicationVndArastraSwi Mime = "(OBSOLETED"

	// KMimeApplicationVndAristanetworksSwi
	//
	// English:
	//
	//  Application type 'vnd.aristanetworks.swi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.aristanetworks.swi'
	KMimeApplicationVndAristanetworksSwi Mime = "application/vnd.aristanetworks.swi"

	// KMimeApplicationVndArtisanJson
	//
	// English:
	//
	//  Application type 'vnd.artisan+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.artisan+json'
	KMimeApplicationVndArtisanJson Mime = "application/vnd.artisan+json"

	// KMimeApplicationVndArtsquare
	//
	// English:
	//
	//  Application type 'vnd.artsquare'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.artsquare'
	KMimeApplicationVndArtsquare Mime = "application/vnd.artsquare"

	// KMimeApplicationVndAstraeaSoftwareIota
	//
	// English:
	//
	//  Application type 'vnd.astraea-software.iota'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.astraea-software.iota'
	KMimeApplicationVndAstraeaSoftwareIota Mime = "application/vnd.astraea-software.iota"

	// KMimeApplicationVndAudiograph
	//
	// English:
	//
	//  Application type 'vnd.audiograph'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.audiograph'
	KMimeApplicationVndAudiograph Mime = "application/vnd.audiograph"

	// KMimeApplicationVndAutopackage
	//
	// English:
	//
	//  Application type 'vnd.autopackage'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.autopackage'
	KMimeApplicationVndAutopackage Mime = "application/vnd.autopackage"

	// KMimeApplicationVndAvalonJson
	//
	// English:
	//
	//  Application type 'vnd.avalon+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.avalon+json'
	KMimeApplicationVndAvalonJson Mime = "application/vnd.avalon+json"

	// KMimeApplicationVndAvistarXml
	//
	// English:
	//
	//  Application type 'vnd.avistar+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.avistar+xml'
	KMimeApplicationVndAvistarXml Mime = "application/vnd.avistar+xml"

	// KMimeApplicationVndBalsamiqBmmlXml
	//
	// English:
	//
	//  Application type 'vnd.balsamiq.bmml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.balsamiq.bmml+xml'
	KMimeApplicationVndBalsamiqBmmlXml Mime = "application/vnd.balsamiq.bmml+xml"

	// KMimeApplicationVndBananaAccounting
	//
	// English:
	//
	//  Application type 'vnd.banana-accounting'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.banana-accounting'
	KMimeApplicationVndBananaAccounting Mime = "application/vnd.banana-accounting"

	// KMimeApplicationVndBbfUspError
	//
	// English:
	//
	//  Application type 'vnd.bbf.usp.error'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bbf.usp.error'
	KMimeApplicationVndBbfUspError Mime = "application/vnd.bbf.usp.error"

	// KMimeApplicationVndBbfUspMsg
	//
	// English:
	//
	//  Application type 'vnd.bbf.usp.msg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bbf.usp.msg'
	KMimeApplicationVndBbfUspMsg Mime = "application/vnd.bbf.usp.msg"

	// KMimeApplicationVndBbfUspMsgJson
	//
	// English:
	//
	//  Application type 'vnd.bbf.usp.msg+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bbf.usp.msg+json'
	KMimeApplicationVndBbfUspMsgJson Mime = "application/vnd.bbf.usp.msg+json"

	// KMimeApplicationVndBalsamiqBmpr
	//
	// English:
	//
	//  Application type 'vnd.balsamiq.bmpr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.balsamiq.bmpr'
	KMimeApplicationVndBalsamiqBmpr Mime = "application/vnd.balsamiq.bmpr"

	// KMimeApplicationVndBekitzurStechJson
	//
	// English:
	//
	//  Application type 'vnd.bekitzur-stech+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bekitzur-stech+json'
	KMimeApplicationVndBekitzurStechJson Mime = "application/vnd.bekitzur-stech+json"

	// KMimeApplicationVndBintMedContent
	//
	// English:
	//
	//  Application type 'vnd.bint.med-content'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bint.med-content'
	KMimeApplicationVndBintMedContent Mime = "application/vnd.bint.med-content"

	// KMimeApplicationVndBiopaxRdfXml
	//
	// English:
	//
	//  Application type 'vnd.biopax.rdf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.biopax.rdf+xml'
	KMimeApplicationVndBiopaxRdfXml Mime = "application/vnd.biopax.rdf+xml"

	// KMimeApplicationVndBlinkIdbValueWrapper
	//
	// English:
	//
	//  Application type 'vnd.blink-idb-value-wrapper'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.blink-idb-value-wrapper'
	KMimeApplicationVndBlinkIdbValueWrapper Mime = "application/vnd.blink-idb-value-wrapper"

	// KMimeApplicationVndBlueiceMultipass
	//
	// English:
	//
	//  Application type 'vnd.blueice.multipass'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.blueice.multipass'
	KMimeApplicationVndBlueiceMultipass Mime = "application/vnd.blueice.multipass"

	// KMimeApplicationVndBluetoothEpOob
	//
	// English:
	//
	//  Application type 'vnd.bluetooth.ep.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bluetooth.ep.oob'
	KMimeApplicationVndBluetoothEpOob Mime = "application/vnd.bluetooth.ep.oob"

	// KMimeApplicationVndBluetoothLeOob
	//
	// English:
	//
	//  Application type 'vnd.bluetooth.le.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bluetooth.le.oob'
	KMimeApplicationVndBluetoothLeOob Mime = "application/vnd.bluetooth.le.oob"

	// KMimeApplicationVndBmi
	//
	// English:
	//
	//  Application type 'vnd.bmi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bmi'
	KMimeApplicationVndBmi Mime = "application/vnd.bmi"

	// KMimeApplicationVndBpf
	//
	// English:
	//
	//  Application type 'vnd.bpf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bpf'
	KMimeApplicationVndBpf Mime = "application/vnd.bpf"

	// KMimeApplicationVndBpf3
	//
	// English:
	//
	//  Application type 'vnd.bpf3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.bpf3'
	KMimeApplicationVndBpf3 Mime = "application/vnd.bpf3"

	// KMimeApplicationVndBusinessobjects
	//
	// English:
	//
	//  Application type 'vnd.businessobjects'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.businessobjects'
	KMimeApplicationVndBusinessobjects Mime = "application/vnd.businessobjects"

	// KMimeApplicationVndByuUapiJson
	//
	// English:
	//
	//  Application type 'vnd.byu.uapi+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.byu.uapi+json'
	KMimeApplicationVndByuUapiJson Mime = "application/vnd.byu.uapi+json"

	// KMimeApplicationVndCabJscript
	//
	// English:
	//
	//  Application type 'vnd.cab-jscript'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cab-jscript'
	KMimeApplicationVndCabJscript Mime = "application/vnd.cab-jscript"

	// KMimeApplicationVndCanonCpdl
	//
	// English:
	//
	//  Application type 'vnd.canon-cpdl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.canon-cpdl'
	KMimeApplicationVndCanonCpdl Mime = "application/vnd.canon-cpdl"

	// KMimeApplicationVndCanonLips
	//
	// English:
	//
	//  Application type 'vnd.canon-lips'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.canon-lips'
	KMimeApplicationVndCanonLips Mime = "application/vnd.canon-lips"

	// KMimeApplicationVndCapasystemsPgJson
	//
	// English:
	//
	//  Application type 'vnd.capasystems-pg+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.capasystems-pg+json'
	KMimeApplicationVndCapasystemsPgJson Mime = "application/vnd.capasystems-pg+json"

	// KMimeApplicationVndCendioThinlincClientconf
	//
	// English:
	//
	//  Application type 'vnd.cendio.thinlinc.clientconf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cendio.thinlinc.clientconf'
	KMimeApplicationVndCendioThinlincClientconf Mime = "application/vnd.cendio.thinlinc.clientconf"

	// KMimeApplicationVndCenturySystemsTcpStream
	//
	// English:
	//
	//  Application type 'vnd.century-systems.tcp_stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.century-systems.tcp_stream'
	KMimeApplicationVndCenturySystemsTcpStream Mime = "application/vnd.century-systems.tcp_stream"

	// KMimeApplicationVndChemdrawXml
	//
	// English:
	//
	//  Application type 'vnd.chemdraw+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.chemdraw+xml'
	KMimeApplicationVndChemdrawXml Mime = "application/vnd.chemdraw+xml"

	// KMimeApplicationVndChessPgn
	//
	// English:
	//
	//  Application type 'vnd.chess-pgn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.chess-pgn'
	KMimeApplicationVndChessPgn Mime = "application/vnd.chess-pgn"

	// KMimeApplicationVndChipnutsKaraokeMmd
	//
	// English:
	//
	//  Application type 'vnd.chipnuts.karaoke-mmd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.chipnuts.karaoke-mmd'
	KMimeApplicationVndChipnutsKaraokeMmd Mime = "application/vnd.chipnuts.karaoke-mmd"

	// KMimeApplicationVndCiedi
	//
	// English:
	//
	//  Application type 'vnd.ciedi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ciedi'
	KMimeApplicationVndCiedi Mime = "application/vnd.ciedi"

	// KMimeApplicationVndCinderella
	//
	// English:
	//
	//  Application type 'vnd.cinderella'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cinderella'
	KMimeApplicationVndCinderella Mime = "application/vnd.cinderella"

	// KMimeApplicationVndCirpackIsdnExt
	//
	// English:
	//
	//  Application type 'vnd.cirpack.isdn-ext'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cirpack.isdn-ext'
	KMimeApplicationVndCirpackIsdnExt Mime = "application/vnd.cirpack.isdn-ext"

	// KMimeApplicationVndCitationstylesStyleXml
	//
	// English:
	//
	//  Application type 'vnd.citationstyles.style+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.citationstyles.style+xml'
	KMimeApplicationVndCitationstylesStyleXml Mime = "application/vnd.citationstyles.style+xml"

	// KMimeApplicationVndClaymore
	//
	// English:
	//
	//  Application type 'vnd.claymore'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.claymore'
	KMimeApplicationVndClaymore Mime = "application/vnd.claymore"

	// KMimeApplicationVndCloantoRp9
	//
	// English:
	//
	//  Application type 'vnd.cloanto.rp9'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cloanto.rp9'
	KMimeApplicationVndCloantoRp9 Mime = "application/vnd.cloanto.rp9"

	// KMimeApplicationVndClonkC4group
	//
	// English:
	//
	//  Application type 'vnd.clonk.c4group'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.clonk.c4group'
	KMimeApplicationVndClonkC4group Mime = "application/vnd.clonk.c4group"

	// KMimeApplicationVndCluetrustCartomobileConfig
	//
	// English:
	//
	//  Application type 'vnd.cluetrust.cartomobile-config'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cluetrust.cartomobile-config'
	KMimeApplicationVndCluetrustCartomobileConfig Mime = "application/vnd.cluetrust.cartomobile-config"

	// KMimeApplicationVndCluetrustCartomobileConfigPkg
	//
	// English:
	//
	//  Application type 'vnd.cluetrust.cartomobile-config-pkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cluetrust.cartomobile-config-pkg'
	KMimeApplicationVndCluetrustCartomobileConfigPkg Mime = "application/vnd.cluetrust.cartomobile-config-pkg"

	// KMimeApplicationVndCoffeescript
	//
	// English:
	//
	//  Application type 'vnd.coffeescript'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.coffeescript'
	KMimeApplicationVndCoffeescript Mime = "application/vnd.coffeescript"

	// KMimeApplicationVndCollabioXodocumentsDocument
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.document'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.document'
	KMimeApplicationVndCollabioXodocumentsDocument Mime = "application/vnd.collabio.xodocuments.document"

	// KMimeApplicationVndCollabioXodocumentsDocumentTemplate
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.document-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.document-template'
	KMimeApplicationVndCollabioXodocumentsDocumentTemplate Mime = "application/vnd.collabio.xodocuments.document-template"

	// KMimeApplicationVndCollabioXodocumentsPresentation
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.presentation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.presentation'
	KMimeApplicationVndCollabioXodocumentsPresentation Mime = "application/vnd.collabio.xodocuments.presentation"

	// KMimeApplicationVndCollabioXodocumentsPresentationTemplate
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.presentation-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.presentation-template'
	KMimeApplicationVndCollabioXodocumentsPresentationTemplate Mime = "application/vnd.collabio.xodocuments.presentation-template"

	// KMimeApplicationVndCollabioXodocumentsSpreadsheet
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.spreadsheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.spreadsheet'
	KMimeApplicationVndCollabioXodocumentsSpreadsheet Mime = "application/vnd.collabio.xodocuments.spreadsheet"

	// KMimeApplicationVndCollabioXodocumentsSpreadsheetTemplate
	//
	// English:
	//
	//  Application type 'vnd.collabio.xodocuments.spreadsheet-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collabio.xodocuments.spreadsheet-template'
	KMimeApplicationVndCollabioXodocumentsSpreadsheetTemplate Mime = "application/vnd.collabio.xodocuments.spreadsheet-template"

	// KMimeApplicationVndCollectionDocJson
	//
	// English:
	//
	//  Application type 'vnd.collection.doc+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collection.doc+json'
	KMimeApplicationVndCollectionDocJson Mime = "application/vnd.collection.doc+json"

	// KMimeApplicationVndCollectionJson
	//
	// English:
	//
	//  Application type 'vnd.collection+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collection+json'
	KMimeApplicationVndCollectionJson Mime = "application/vnd.collection+json"

	// KMimeApplicationVndCollectionNextJson
	//
	// English:
	//
	//  Application type 'vnd.collection.next+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.collection.next+json'
	KMimeApplicationVndCollectionNextJson Mime = "application/vnd.collection.next+json"

	// KMimeApplicationVndComicbookRar
	//
	// English:
	//
	//  Application type 'vnd.comicbook-rar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.comicbook-rar'
	KMimeApplicationVndComicbookRar Mime = "application/vnd.comicbook-rar"

	// KMimeApplicationVndComicbookZip
	//
	// English:
	//
	//  Application type 'vnd.comicbook+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.comicbook+zip'
	KMimeApplicationVndComicbookZip Mime = "application/vnd.comicbook+zip"

	// KMimeApplicationVndCommerceBattelle
	//
	// English:
	//
	//  Application type 'vnd.commerce-battelle'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.commerce-battelle'
	KMimeApplicationVndCommerceBattelle Mime = "application/vnd.commerce-battelle"

	// KMimeApplicationVndCommonspace
	//
	// English:
	//
	//  Application type 'vnd.commonspace'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.commonspace'
	KMimeApplicationVndCommonspace Mime = "application/vnd.commonspace"

	// KMimeApplicationVndCoreosIgnitionJson
	//
	// English:
	//
	//  Application type 'vnd.coreos.ignition+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.coreos.ignition+json'
	KMimeApplicationVndCoreosIgnitionJson Mime = "application/vnd.coreos.ignition+json"

	// KMimeApplicationVndCosmocaller
	//
	// English:
	//
	//  Application type 'vnd.cosmocaller'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cosmocaller'
	KMimeApplicationVndCosmocaller Mime = "application/vnd.cosmocaller"

	// KMimeApplicationVndContactCmsg
	//
	// English:
	//
	//  Application type 'vnd.contact.cmsg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.contact.cmsg'
	KMimeApplicationVndContactCmsg Mime = "application/vnd.contact.cmsg"

	// KMimeApplicationVndCrickClicker
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker'
	KMimeApplicationVndCrickClicker Mime = "application/vnd.crick.clicker"

	// KMimeApplicationVndCrickClickerKeyboard
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.keyboard'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.keyboard'
	KMimeApplicationVndCrickClickerKeyboard Mime = "application/vnd.crick.clicker.keyboard"

	// KMimeApplicationVndCrickClickerPalette
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.palette'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.palette'
	KMimeApplicationVndCrickClickerPalette Mime = "application/vnd.crick.clicker.palette"

	// KMimeApplicationVndCrickClickerTemplate
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.template'
	KMimeApplicationVndCrickClickerTemplate Mime = "application/vnd.crick.clicker.template"

	// KMimeApplicationVndCrickClickerWordbank
	//
	// English:
	//
	//  Application type 'vnd.crick.clicker.wordbank'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crick.clicker.wordbank'
	KMimeApplicationVndCrickClickerWordbank Mime = "application/vnd.crick.clicker.wordbank"

	// KMimeApplicationVndCriticaltoolsWbsXml
	//
	// English:
	//
	//  Application type 'vnd.criticaltools.wbs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.criticaltools.wbs+xml'
	KMimeApplicationVndCriticaltoolsWbsXml Mime = "application/vnd.criticaltools.wbs+xml"

	// KMimeApplicationVndCryptiiPipeJson
	//
	// English:
	//
	//  Application type 'vnd.cryptii.pipe+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cryptii.pipe+json'
	KMimeApplicationVndCryptiiPipeJson Mime = "application/vnd.cryptii.pipe+json"

	// KMimeApplicationVndCryptoShadeFile
	//
	// English:
	//
	//  Application type 'vnd.crypto-shade-file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.crypto-shade-file'
	KMimeApplicationVndCryptoShadeFile Mime = "application/vnd.crypto-shade-file"

	// KMimeApplicationVndCryptomatorEncrypted
	//
	// English:
	//
	//  Application type 'vnd.cryptomator.encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cryptomator.encrypted'
	KMimeApplicationVndCryptomatorEncrypted Mime = "application/vnd.cryptomator.encrypted"

	// KMimeApplicationVndCryptomatorVault
	//
	// English:
	//
	//  Application type 'vnd.cryptomator.vault'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cryptomator.vault'
	KMimeApplicationVndCryptomatorVault Mime = "application/vnd.cryptomator.vault"

	// KMimeApplicationVndCtcPosml
	//
	// English:
	//
	//  Application type 'vnd.ctc-posml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ctc-posml'
	KMimeApplicationVndCtcPosml Mime = "application/vnd.ctc-posml"

	// KMimeApplicationVndCtctWsXml
	//
	// English:
	//
	//  Application type 'vnd.ctct.ws+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ctct.ws+xml'
	KMimeApplicationVndCtctWsXml Mime = "application/vnd.ctct.ws+xml"

	// KMimeApplicationVndCupsPdf
	//
	// English:
	//
	//  Application type 'vnd.cups-pdf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-pdf'
	KMimeApplicationVndCupsPdf Mime = "application/vnd.cups-pdf"

	// KMimeApplicationVndCupsPostscript
	//
	// English:
	//
	//  Application type 'vnd.cups-postscript'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-postscript'
	KMimeApplicationVndCupsPostscript Mime = "application/vnd.cups-postscript"

	// KMimeApplicationVndCupsPpd
	//
	// English:
	//
	//  Application type 'vnd.cups-ppd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-ppd'
	KMimeApplicationVndCupsPpd Mime = "application/vnd.cups-ppd"

	// KMimeApplicationVndCupsRaster
	//
	// English:
	//
	//  Application type 'vnd.cups-raster'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-raster'
	KMimeApplicationVndCupsRaster Mime = "application/vnd.cups-raster"

	// KMimeApplicationVndCupsRaw
	//
	// English:
	//
	//  Application type 'vnd.cups-raw'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cups-raw'
	KMimeApplicationVndCupsRaw Mime = "application/vnd.cups-raw"

	// KMimeApplicationVndCurl
	//
	// English:
	//
	//  Application type 'vnd.curl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.curl'
	KMimeApplicationVndCurl Mime = "application/vnd.curl"

	// KMimeApplicationVndCyanDeanRootXml
	//
	// English:
	//
	//  Application type 'vnd.cyan.dean.root+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cyan.dean.root+xml'
	KMimeApplicationVndCyanDeanRootXml Mime = "application/vnd.cyan.dean.root+xml"

	// KMimeApplicationVndCybank
	//
	// English:
	//
	//  Application type 'vnd.cybank'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cybank'
	KMimeApplicationVndCybank Mime = "application/vnd.cybank"

	// KMimeApplicationVndCyclonedxJson
	//
	// English:
	//
	//  Application type 'vnd.cyclonedx+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cyclonedx+json'
	KMimeApplicationVndCyclonedxJson Mime = "application/vnd.cyclonedx+json"

	// KMimeApplicationVndCyclonedxXml
	//
	// English:
	//
	//  Application type 'vnd.cyclonedx+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.cyclonedx+xml'
	KMimeApplicationVndCyclonedxXml Mime = "application/vnd.cyclonedx+xml"

	// KMimeApplicationVndD2lCoursepackage1p0Zip
	//
	// English:
	//
	//  Application type 'vnd.d2l.coursepackage1p0+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.d2l.coursepackage1p0+zip'
	KMimeApplicationVndD2lCoursepackage1p0Zip Mime = "application/vnd.d2l.coursepackage1p0+zip"

	// KMimeApplicationVndD3mDataset
	//
	// English:
	//
	//  Application type 'vnd.d3m-dataset'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.d3m-dataset'
	KMimeApplicationVndD3mDataset Mime = "application/vnd.d3m-dataset"

	// KMimeApplicationVndD3mProblem
	//
	// English:
	//
	//  Application type 'vnd.d3m-problem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.d3m-problem'
	KMimeApplicationVndD3mProblem Mime = "application/vnd.d3m-problem"

	// KMimeApplicationVndDart
	//
	// English:
	//
	//  Application type 'vnd.dart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dart'
	KMimeApplicationVndDart Mime = "application/vnd.dart"

	// KMimeApplicationVndDataVisionRdz
	//
	// English:
	//
	//  Application type 'vnd.data-vision.rdz'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.data-vision.rdz'
	KMimeApplicationVndDataVisionRdz Mime = "application/vnd.data-vision.rdz"

	// KMimeApplicationVndDatapackageJson
	//
	// English:
	//
	//  Application type 'vnd.datapackage+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.datapackage+json'
	KMimeApplicationVndDatapackageJson Mime = "application/vnd.datapackage+json"

	// KMimeApplicationVndDataresourceJson
	//
	// English:
	//
	//  Application type 'vnd.dataresource+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dataresource+json'
	KMimeApplicationVndDataresourceJson Mime = "application/vnd.dataresource+json"

	// KMimeApplicationVndDbf
	//
	// English:
	//
	//  Application type 'vnd.dbf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dbf'
	KMimeApplicationVndDbf Mime = "application/vnd.dbf"

	// KMimeApplicationVndDebianBinaryPackage
	//
	// English:
	//
	//  Application type 'vnd.debian.binary-package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.debian.binary-package'
	KMimeApplicationVndDebianBinaryPackage Mime = "application/vnd.debian.binary-package"

	// KMimeApplicationVndDeceData
	//
	// English:
	//
	//  Application type 'vnd.dece.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.data'
	KMimeApplicationVndDeceData Mime = "application/vnd.dece.data"

	// KMimeApplicationVndDeceTtmlXml
	//
	// English:
	//
	//  Application type 'vnd.dece.ttml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.ttml+xml'
	KMimeApplicationVndDeceTtmlXml Mime = "application/vnd.dece.ttml+xml"

	// KMimeApplicationVndDeceUnspecified
	//
	// English:
	//
	//  Application type 'vnd.dece.unspecified'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.unspecified'
	KMimeApplicationVndDeceUnspecified Mime = "application/vnd.dece.unspecified"

	// KMimeApplicationVndDeceZip
	//
	// English:
	//
	//  Application type 'vnd.dece.zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dece.zip'
	KMimeApplicationVndDeceZip Mime = "application/vnd.dece.zip"

	// KMimeApplicationVndDenovoFcselayoutLink
	//
	// English:
	//
	//  Application type 'vnd.denovo.fcselayout-link'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.denovo.fcselayout-link'
	KMimeApplicationVndDenovoFcselayoutLink Mime = "application/vnd.denovo.fcselayout-link"

	// KMimeApplicationVndDesmumeMovie
	//
	// English:
	//
	//  Application type 'vnd.desmume.movie'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.desmume.movie'
	KMimeApplicationVndDesmumeMovie Mime = "application/vnd.desmume.movie"

	// KMimeApplicationVndDirBiPlateDlNosuffix
	//
	// English:
	//
	//  Application type 'vnd.dir-bi.plate-dl-nosuffix'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dir-bi.plate-dl-nosuffix'
	KMimeApplicationVndDirBiPlateDlNosuffix Mime = "application/vnd.dir-bi.plate-dl-nosuffix"

	// KMimeApplicationVndDmDelegationXml
	//
	// English:
	//
	//  Application type 'vnd.dm.delegation+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dm.delegation+xml'
	KMimeApplicationVndDmDelegationXml Mime = "application/vnd.dm.delegation+xml"

	// KMimeApplicationVndDna
	//
	// English:
	//
	//  Application type 'vnd.dna'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dna'
	KMimeApplicationVndDna Mime = "application/vnd.dna"

	// KMimeApplicationVndDocumentJson
	//
	// English:
	//
	//  Application type 'vnd.document+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.document+json'
	KMimeApplicationVndDocumentJson Mime = "application/vnd.document+json"

	// KMimeApplicationVndDolbyMobile1
	//
	// English:
	//
	//  Application type 'vnd.dolby.mobile.1'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dolby.mobile.1'
	KMimeApplicationVndDolbyMobile1 Mime = "application/vnd.dolby.mobile.1"

	// KMimeApplicationVndDolbyMobile2
	//
	// English:
	//
	//  Application type 'vnd.dolby.mobile.2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dolby.mobile.2'
	KMimeApplicationVndDolbyMobile2 Mime = "application/vnd.dolby.mobile.2"

	// KMimeApplicationVndDoremirScorecloudBinaryDocument
	//
	// English:
	//
	//  Application type 'vnd.doremir.scorecloud-binary-document'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.doremir.scorecloud-binary-document'
	KMimeApplicationVndDoremirScorecloudBinaryDocument Mime = "application/vnd.doremir.scorecloud-binary-document"

	// KMimeApplicationVndDpgraph
	//
	// English:
	//
	//  Application type 'vnd.dpgraph'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dpgraph'
	KMimeApplicationVndDpgraph Mime = "application/vnd.dpgraph"

	// KMimeApplicationVndDreamfactory
	//
	// English:
	//
	//  Application type 'vnd.dreamfactory'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dreamfactory'
	KMimeApplicationVndDreamfactory Mime = "application/vnd.dreamfactory"

	// KMimeApplicationVndDriveJson
	//
	// English:
	//
	//  Application type 'vnd.drive+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.drive+json'
	KMimeApplicationVndDriveJson Mime = "application/vnd.drive+json"

	// KMimeApplicationVndDtgLocal
	//
	// English:
	//
	//  Application type 'vnd.dtg.local'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dtg.local'
	KMimeApplicationVndDtgLocal Mime = "application/vnd.dtg.local"

	// KMimeApplicationVndDtgLocalFlash
	//
	// English:
	//
	//  Application type 'vnd.dtg.local.flash'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dtg.local.flash'
	KMimeApplicationVndDtgLocalFlash Mime = "application/vnd.dtg.local.flash"

	// KMimeApplicationVndDtgLocalHtml
	//
	// English:
	//
	//  Application type 'vnd.dtg.local.html'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dtg.local.html'
	KMimeApplicationVndDtgLocalHtml Mime = "application/vnd.dtg.local.html"

	// KMimeApplicationVndDvbAit
	//
	// English:
	//
	//  Application type 'vnd.dvb.ait'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ait'
	KMimeApplicationVndDvbAit Mime = "application/vnd.dvb.ait"

	// KMimeApplicationVndDvbDvbislXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.dvbisl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.dvbisl+xml'
	KMimeApplicationVndDvbDvbislXml Mime = "application/vnd.dvb.dvbisl+xml"

	// KMimeApplicationVndDvbDvbj
	//
	// English:
	//
	//  Application type 'vnd.dvb.dvbj'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.dvbj'
	KMimeApplicationVndDvbDvbj Mime = "application/vnd.dvb.dvbj"

	// KMimeApplicationVndDvbEsgcontainer
	//
	// English:
	//
	//  Application type 'vnd.dvb.esgcontainer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.esgcontainer'
	KMimeApplicationVndDvbEsgcontainer Mime = "application/vnd.dvb.esgcontainer"

	// KMimeApplicationVndDvbIpdcdftnotifaccess
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcdftnotifaccess'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcdftnotifaccess'
	KMimeApplicationVndDvbIpdcdftnotifaccess Mime = "application/vnd.dvb.ipdcdftnotifaccess"

	// KMimeApplicationVndDvbIpdcesgaccess
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcesgaccess'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcesgaccess'
	KMimeApplicationVndDvbIpdcesgaccess Mime = "application/vnd.dvb.ipdcesgaccess"

	// KMimeApplicationVndDvbIpdcesgaccess2
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcesgaccess2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcesgaccess2'
	KMimeApplicationVndDvbIpdcesgaccess2 Mime = "application/vnd.dvb.ipdcesgaccess2"

	// KMimeApplicationVndDvbIpdcesgpdd
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcesgpdd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcesgpdd'
	KMimeApplicationVndDvbIpdcesgpdd Mime = "application/vnd.dvb.ipdcesgpdd"

	// KMimeApplicationVndDvbIpdcroaming
	//
	// English:
	//
	//  Application type 'vnd.dvb.ipdcroaming'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.ipdcroaming'
	KMimeApplicationVndDvbIpdcroaming Mime = "application/vnd.dvb.ipdcroaming"

	// KMimeApplicationVndDvbIptvAlfecBase
	//
	// English:
	//
	//  Application type 'vnd.dvb.iptv.alfec-base'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.iptv.alfec-base'
	KMimeApplicationVndDvbIptvAlfecBase Mime = "application/vnd.dvb.iptv.alfec-base"

	// KMimeApplicationVndDvbIptvAlfecEnhancement
	//
	// English:
	//
	//  Application type 'vnd.dvb.iptv.alfec-enhancement'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.iptv.alfec-enhancement'
	KMimeApplicationVndDvbIptvAlfecEnhancement Mime = "application/vnd.dvb.iptv.alfec-enhancement"

	// KMimeApplicationVndDvbNotifAggregateRootXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-aggregate-root+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-aggregate-root+xml'
	KMimeApplicationVndDvbNotifAggregateRootXml Mime = "application/vnd.dvb.notif-aggregate-root+xml"

	// KMimeApplicationVndDvbNotifContainerXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-container+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-container+xml'
	KMimeApplicationVndDvbNotifContainerXml Mime = "application/vnd.dvb.notif-container+xml"

	// KMimeApplicationVndDvbNotifGenericXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-generic+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-generic+xml'
	KMimeApplicationVndDvbNotifGenericXml Mime = "application/vnd.dvb.notif-generic+xml"

	// KMimeApplicationVndDvbNotifIaMsglistXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-ia-msglist+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-ia-msglist+xml'
	KMimeApplicationVndDvbNotifIaMsglistXml Mime = "application/vnd.dvb.notif-ia-msglist+xml"

	// KMimeApplicationVndDvbNotifIaRegistrationRequestXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-ia-registration-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-ia-registration-request+xml'
	KMimeApplicationVndDvbNotifIaRegistrationRequestXml Mime = "application/vnd.dvb.notif-ia-registration-request+xml"

	// KMimeApplicationVndDvbNotifIaRegistrationResponseXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-ia-registration-response+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-ia-registration-response+xml'
	KMimeApplicationVndDvbNotifIaRegistrationResponseXml Mime = "application/vnd.dvb.notif-ia-registration-response+xml"

	// KMimeApplicationVndDvbNotifInitXml
	//
	// English:
	//
	//  Application type 'vnd.dvb.notif-init+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.notif-init+xml'
	KMimeApplicationVndDvbNotifInitXml Mime = "application/vnd.dvb.notif-init+xml"

	// KMimeApplicationVndDvbPfr
	//
	// English:
	//
	//  Application type 'vnd.dvb.pfr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.pfr'
	KMimeApplicationVndDvbPfr Mime = "application/vnd.dvb.pfr"

	// KMimeApplicationVndDvbService
	//
	// English:
	//
	//  Application type 'vnd.dvb.service'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dvb.service'
	KMimeApplicationVndDvbService Mime = "application/vnd.dvb.service"

	// KMimeApplicationVndDxr
	//
	// English:
	//
	//  Application type 'vnd.dxr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dxr'
	KMimeApplicationVndDxr Mime = "application/vnd.dxr"

	// KMimeApplicationVndDynageo
	//
	// English:
	//
	//  Application type 'vnd.dynageo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dynageo'
	KMimeApplicationVndDynageo Mime = "application/vnd.dynageo"

	// KMimeApplicationVndDzr
	//
	// English:
	//
	//  Application type 'vnd.dzr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.dzr'
	KMimeApplicationVndDzr Mime = "application/vnd.dzr"

	// KMimeApplicationVndEasykaraokeCdgdownload
	//
	// English:
	//
	//  Application type 'vnd.easykaraoke.cdgdownload'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.easykaraoke.cdgdownload'
	KMimeApplicationVndEasykaraokeCdgdownload Mime = "application/vnd.easykaraoke.cdgdownload"

	// KMimeApplicationVndEcipRlp
	//
	// English:
	//
	//  Application type 'vnd.ecip.rlp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecip.rlp'
	KMimeApplicationVndEcipRlp Mime = "application/vnd.ecip.rlp"

	// KMimeApplicationVndEcdisUpdate
	//
	// English:
	//
	//  Application type 'vnd.ecdis-update'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecdis-update'
	KMimeApplicationVndEcdisUpdate Mime = "application/vnd.ecdis-update"

	// KMimeApplicationVndEclipseDittoJson
	//
	// English:
	//
	//  Application type 'vnd.eclipse.ditto+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eclipse.ditto+json'
	KMimeApplicationVndEclipseDittoJson Mime = "application/vnd.eclipse.ditto+json"

	// KMimeApplicationVndEcowinChart
	//
	// English:
	//
	//  Application type 'vnd.ecowin.chart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.chart'
	KMimeApplicationVndEcowinChart Mime = "application/vnd.ecowin.chart"

	// KMimeApplicationVndEcowinFilerequest
	//
	// English:
	//
	//  Application type 'vnd.ecowin.filerequest'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.filerequest'
	KMimeApplicationVndEcowinFilerequest Mime = "application/vnd.ecowin.filerequest"

	// KMimeApplicationVndEcowinFileupdate
	//
	// English:
	//
	//  Application type 'vnd.ecowin.fileupdate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.fileupdate'
	KMimeApplicationVndEcowinFileupdate Mime = "application/vnd.ecowin.fileupdate"

	// KMimeApplicationVndEcowinSeries
	//
	// English:
	//
	//  Application type 'vnd.ecowin.series'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.series'
	KMimeApplicationVndEcowinSeries Mime = "application/vnd.ecowin.series"

	// KMimeApplicationVndEcowinSeriesrequest
	//
	// English:
	//
	//  Application type 'vnd.ecowin.seriesrequest'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.seriesrequest'
	KMimeApplicationVndEcowinSeriesrequest Mime = "application/vnd.ecowin.seriesrequest"

	// KMimeApplicationVndEcowinSeriesupdate
	//
	// English:
	//
	//  Application type 'vnd.ecowin.seriesupdate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ecowin.seriesupdate'
	KMimeApplicationVndEcowinSeriesupdate Mime = "application/vnd.ecowin.seriesupdate"

	// KMimeApplicationVndEfiImg
	//
	// English:
	//
	//  Application type 'vnd.efi.img'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.efi.img'
	KMimeApplicationVndEfiImg Mime = "application/vnd.efi.img"

	// KMimeApplicationVndEfiIso
	//
	// English:
	//
	//  Application type 'vnd.efi.iso'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.efi.iso'
	KMimeApplicationVndEfiIso Mime = "application/vnd.efi.iso"

	// KMimeApplicationVndEmclientAccessrequestXml
	//
	// English:
	//
	//  Application type 'vnd.emclient.accessrequest+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.emclient.accessrequest+xml'
	KMimeApplicationVndEmclientAccessrequestXml Mime = "application/vnd.emclient.accessrequest+xml"

	// KMimeApplicationVndEnliven
	//
	// English:
	//
	//  Application type 'vnd.enliven'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.enliven'
	KMimeApplicationVndEnliven Mime = "application/vnd.enliven"

	// KMimeApplicationVndEnphaseEnvoy
	//
	// English:
	//
	//  Application type 'vnd.enphase.envoy'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.enphase.envoy'
	KMimeApplicationVndEnphaseEnvoy Mime = "application/vnd.enphase.envoy"

	// KMimeApplicationVndEprintsDataXml
	//
	// English:
	//
	//  Application type 'vnd.eprints.data+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eprints.data+xml'
	KMimeApplicationVndEprintsDataXml Mime = "application/vnd.eprints.data+xml"

	// KMimeApplicationVndEpsonEsf
	//
	// English:
	//
	//  Application type 'vnd.epson.esf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.esf'
	KMimeApplicationVndEpsonEsf Mime = "application/vnd.epson.esf"

	// KMimeApplicationVndEpsonMsf
	//
	// English:
	//
	//  Application type 'vnd.epson.msf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.msf'
	KMimeApplicationVndEpsonMsf Mime = "application/vnd.epson.msf"

	// KMimeApplicationVndEpsonQuickanime
	//
	// English:
	//
	//  Application type 'vnd.epson.quickanime'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.quickanime'
	KMimeApplicationVndEpsonQuickanime Mime = "application/vnd.epson.quickanime"

	// KMimeApplicationVndEpsonSalt
	//
	// English:
	//
	//  Application type 'vnd.epson.salt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.salt'
	KMimeApplicationVndEpsonSalt Mime = "application/vnd.epson.salt"

	// KMimeApplicationVndEpsonSsf
	//
	// English:
	//
	//  Application type 'vnd.epson.ssf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.epson.ssf'
	KMimeApplicationVndEpsonSsf Mime = "application/vnd.epson.ssf"

	// KMimeApplicationVndEricssonQuickcall
	//
	// English:
	//
	//  Application type 'vnd.ericsson.quickcall'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ericsson.quickcall'
	KMimeApplicationVndEricssonQuickcall Mime = "application/vnd.ericsson.quickcall"

	// KMimeApplicationVndEspassEspassZip
	//
	// English:
	//
	//  Application type 'vnd.espass-espass+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.espass-espass+zip'
	KMimeApplicationVndEspassEspassZip Mime = "application/vnd.espass-espass+zip"

	// KMimeApplicationVndEszigno3Xml
	//
	// English:
	//
	//  Application type 'vnd.eszigno3+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eszigno3+xml'
	KMimeApplicationVndEszigno3Xml Mime = "application/vnd.eszigno3+xml"

	// KMimeApplicationVndEtsiAocXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.aoc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.aoc+xml'
	KMimeApplicationVndEtsiAocXml Mime = "application/vnd.etsi.aoc+xml"

	// KMimeApplicationVndEtsiAsicSZip
	//
	// English:
	//
	//  Application type 'vnd.etsi.asic-s+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.asic-s+zip'
	KMimeApplicationVndEtsiAsicSZip Mime = "application/vnd.etsi.asic-s+zip"

	// KMimeApplicationVndEtsiAsicEZip
	//
	// English:
	//
	//  Application type 'vnd.etsi.asic-e+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.asic-e+zip'
	KMimeApplicationVndEtsiAsicEZip Mime = "application/vnd.etsi.asic-e+zip"

	// KMimeApplicationVndEtsiCugXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.cug+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.cug+xml'
	KMimeApplicationVndEtsiCugXml Mime = "application/vnd.etsi.cug+xml"

	// KMimeApplicationVndEtsiIptvcommandXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvcommand+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvcommand+xml'
	KMimeApplicationVndEtsiIptvcommandXml Mime = "application/vnd.etsi.iptvcommand+xml"

	// KMimeApplicationVndEtsiIptvdiscoveryXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvdiscovery+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvdiscovery+xml'
	KMimeApplicationVndEtsiIptvdiscoveryXml Mime = "application/vnd.etsi.iptvdiscovery+xml"

	// KMimeApplicationVndEtsiIptvprofileXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvprofile+xml'
	KMimeApplicationVndEtsiIptvprofileXml Mime = "application/vnd.etsi.iptvprofile+xml"

	// KMimeApplicationVndEtsiIptvsadBcXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsad-bc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsad-bc+xml'
	KMimeApplicationVndEtsiIptvsadBcXml Mime = "application/vnd.etsi.iptvsad-bc+xml"

	// KMimeApplicationVndEtsiIptvsadCodXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsad-cod+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsad-cod+xml'
	KMimeApplicationVndEtsiIptvsadCodXml Mime = "application/vnd.etsi.iptvsad-cod+xml"

	// KMimeApplicationVndEtsiIptvsadNpvrXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsad-npvr+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsad-npvr+xml'
	KMimeApplicationVndEtsiIptvsadNpvrXml Mime = "application/vnd.etsi.iptvsad-npvr+xml"

	// KMimeApplicationVndEtsiIptvserviceXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvservice+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvservice+xml'
	KMimeApplicationVndEtsiIptvserviceXml Mime = "application/vnd.etsi.iptvservice+xml"

	// KMimeApplicationVndEtsiIptvsyncXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvsync+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvsync+xml'
	KMimeApplicationVndEtsiIptvsyncXml Mime = "application/vnd.etsi.iptvsync+xml"

	// KMimeApplicationVndEtsiIptvueprofileXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.iptvueprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.iptvueprofile+xml'
	KMimeApplicationVndEtsiIptvueprofileXml Mime = "application/vnd.etsi.iptvueprofile+xml"

	// KMimeApplicationVndEtsiMcidXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.mcid+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.mcid+xml'
	KMimeApplicationVndEtsiMcidXml Mime = "application/vnd.etsi.mcid+xml"

	// KMimeApplicationVndEtsiMheg5
	//
	// English:
	//
	//  Application type 'vnd.etsi.mheg5'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.mheg5'
	KMimeApplicationVndEtsiMheg5 Mime = "application/vnd.etsi.mheg5"

	// KMimeApplicationVndEtsiOverloadControlPolicyDatasetXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.overload-control-policy-dataset+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.overload-control-policy-dataset+xml'
	KMimeApplicationVndEtsiOverloadControlPolicyDatasetXml Mime = "application/vnd.etsi.overload-control-policy-dataset+xml"

	// KMimeApplicationVndEtsiPstnXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.pstn+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.pstn+xml'
	KMimeApplicationVndEtsiPstnXml Mime = "application/vnd.etsi.pstn+xml"

	// KMimeApplicationVndEtsiSciXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.sci+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.sci+xml'
	KMimeApplicationVndEtsiSciXml Mime = "application/vnd.etsi.sci+xml"

	// KMimeApplicationVndEtsiSimservsXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.simservs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.simservs+xml'
	KMimeApplicationVndEtsiSimservsXml Mime = "application/vnd.etsi.simservs+xml"

	// KMimeApplicationVndEtsiTimestampToken
	//
	// English:
	//
	//  Application type 'vnd.etsi.timestamp-token'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.timestamp-token'
	KMimeApplicationVndEtsiTimestampToken Mime = "application/vnd.etsi.timestamp-token"

	// KMimeApplicationVndEtsiTslXml
	//
	// English:
	//
	//  Application type 'vnd.etsi.tsl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.tsl+xml'
	KMimeApplicationVndEtsiTslXml Mime = "application/vnd.etsi.tsl+xml"

	// KMimeApplicationVndEtsiTslDer
	//
	// English:
	//
	//  Application type 'vnd.etsi.tsl.der'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.etsi.tsl.der'
	KMimeApplicationVndEtsiTslDer Mime = "application/vnd.etsi.tsl.der"

	// KMimeApplicationVndEuKasparianCarJson
	//
	// English:
	//
	//  Application type 'vnd.eu.kasparian.car+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eu.kasparian.car+json'
	KMimeApplicationVndEuKasparianCarJson Mime = "application/vnd.eu.kasparian.car+json"

	// KMimeApplicationVndEudoraData
	//
	// English:
	//
	//  Application type 'vnd.eudora.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.eudora.data'
	KMimeApplicationVndEudoraData Mime = "application/vnd.eudora.data"

	// KMimeApplicationVndEvolvEcigProfile
	//
	// English:
	//
	//  Application type 'vnd.evolv.ecig.profile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.evolv.ecig.profile'
	KMimeApplicationVndEvolvEcigProfile Mime = "application/vnd.evolv.ecig.profile"

	// KMimeApplicationVndEvolvEcigSettings
	//
	// English:
	//
	//  Application type 'vnd.evolv.ecig.settings'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.evolv.ecig.settings'
	KMimeApplicationVndEvolvEcigSettings Mime = "application/vnd.evolv.ecig.settings"

	// KMimeApplicationVndEvolvEcigTheme
	//
	// English:
	//
	//  Application type 'vnd.evolv.ecig.theme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.evolv.ecig.theme'
	KMimeApplicationVndEvolvEcigTheme Mime = "application/vnd.evolv.ecig.theme"

	// KMimeApplicationVndExstreamEmpowerZip
	//
	// English:
	//
	//  Application type 'vnd.exstream-empower+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.exstream-empower+zip'
	KMimeApplicationVndExstreamEmpowerZip Mime = "application/vnd.exstream-empower+zip"

	// KMimeApplicationVndExstreamPackage
	//
	// English:
	//
	//  Application type 'vnd.exstream-package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.exstream-package'
	KMimeApplicationVndExstreamPackage Mime = "application/vnd.exstream-package"

	// KMimeApplicationVndEzpixAlbum
	//
	// English:
	//
	//  Application type 'vnd.ezpix-album'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ezpix-album'
	KMimeApplicationVndEzpixAlbum Mime = "application/vnd.ezpix-album"

	// KMimeApplicationVndEzpixPackage
	//
	// English:
	//
	//  Application type 'vnd.ezpix-package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ezpix-package'
	KMimeApplicationVndEzpixPackage Mime = "application/vnd.ezpix-package"

	// KMimeApplicationVndFSecureMobile
	//
	// English:
	//
	//  Application type 'vnd.f-secure.mobile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.f-secure.mobile'
	KMimeApplicationVndFSecureMobile Mime = "application/vnd.f-secure.mobile"

	// KMimeApplicationVndFastcopyDiskImage
	//
	// English:
	//
	//  Application type 'vnd.fastcopy-disk-image'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fastcopy-disk-image'
	KMimeApplicationVndFastcopyDiskImage Mime = "application/vnd.fastcopy-disk-image"

	// KMimeApplicationVndFamilysearchGedcomZip
	//
	// English:
	//
	//  Application type 'vnd.familysearch.gedcom+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.familysearch.gedcom+zip'
	KMimeApplicationVndFamilysearchGedcomZip Mime = "application/vnd.familysearch.gedcom+zip"

	// KMimeApplicationVndFdsnMseed
	//
	// English:
	//
	//  Application type 'vnd.fdsn.mseed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fdsn.mseed'
	KMimeApplicationVndFdsnMseed Mime = "application/vnd.fdsn.mseed"

	// KMimeApplicationVndFdsnSeed
	//
	// English:
	//
	//  Application type 'vnd.fdsn.seed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fdsn.seed'
	KMimeApplicationVndFdsnSeed Mime = "application/vnd.fdsn.seed"

	// KMimeApplicationVndFfsns
	//
	// English:
	//
	//  Application type 'vnd.ffsns'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ffsns'
	KMimeApplicationVndFfsns Mime = "application/vnd.ffsns"

	// KMimeApplicationVndFiclabFlbZip
	//
	// English:
	//
	//  Application type 'vnd.ficlab.flb+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ficlab.flb+zip'
	KMimeApplicationVndFiclabFlbZip Mime = "application/vnd.ficlab.flb+zip"

	// KMimeApplicationVndFilmitZfc
	//
	// English:
	//
	//  Application type 'vnd.filmit.zfc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.filmit.zfc'
	KMimeApplicationVndFilmitZfc Mime = "application/vnd.filmit.zfc"

	// KMimeApplicationVndFints
	//
	// English:
	//
	//  Application type 'vnd.fints'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fints'
	KMimeApplicationVndFints Mime = "application/vnd.fints"

	// KMimeApplicationVndFiremonkeysCloudcell
	//
	// English:
	//
	//  Application type 'vnd.firemonkeys.cloudcell'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.firemonkeys.cloudcell'
	KMimeApplicationVndFiremonkeysCloudcell Mime = "application/vnd.firemonkeys.cloudcell"

	// KMimeApplicationVndFloGraphIt
	//
	// English:
	//
	//  Application type 'vnd.FloGraphIt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.FloGraphIt'
	KMimeApplicationVndFloGraphIt Mime = "application/vnd.FloGraphIt"

	// KMimeApplicationVndFluxtimeClip
	//
	// English:
	//
	//  Application type 'vnd.fluxtime.clip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fluxtime.clip'
	KMimeApplicationVndFluxtimeClip Mime = "application/vnd.fluxtime.clip"

	// KMimeApplicationVndFontFontforgeSfd
	//
	// English:
	//
	//  Application type 'vnd.font-fontforge-sfd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.font-fontforge-sfd'
	KMimeApplicationVndFontFontforgeSfd Mime = "application/vnd.font-fontforge-sfd"

	// KMimeApplicationVndFramemaker
	//
	// English:
	//
	//  Application type 'vnd.framemaker'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.framemaker'
	KMimeApplicationVndFramemaker Mime = "application/vnd.framemaker"

	// KMimeApplicationVndFrogansFnc
	//
	// English:
	//
	//  Application type 'vnd.frogans.fnc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.frogans.fnc'
	KMimeApplicationVndFrogansFnc Mime = "(OBSOLETE)"

	// KMimeApplicationVndFrogansLtf
	//
	// English:
	//
	//  Application type 'vnd.frogans.ltf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.frogans.ltf'
	KMimeApplicationVndFrogansLtf Mime = "(OBSOLETE)"

	// KMimeApplicationVndFscWeblaunch
	//
	// English:
	//
	//  Application type 'vnd.fsc.weblaunch'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fsc.weblaunch'
	KMimeApplicationVndFscWeblaunch Mime = "application/vnd.fsc.weblaunch"

	// KMimeApplicationVndFujifilmFbDocuworks
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.docuworks'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.docuworks'
	KMimeApplicationVndFujifilmFbDocuworks Mime = "application/vnd.fujifilm.fb.docuworks"

	// KMimeApplicationVndFujifilmFbDocuworksBinder
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.docuworks.binder'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.docuworks.binder'
	KMimeApplicationVndFujifilmFbDocuworksBinder Mime = "application/vnd.fujifilm.fb.docuworks.binder"

	// KMimeApplicationVndFujifilmFbDocuworksContainer
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.docuworks.container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.docuworks.container'
	KMimeApplicationVndFujifilmFbDocuworksContainer Mime = "application/vnd.fujifilm.fb.docuworks.container"

	// KMimeApplicationVndFujifilmFbJfiXml
	//
	// English:
	//
	//  Application type 'vnd.fujifilm.fb.jfi+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujifilm.fb.jfi+xml'
	KMimeApplicationVndFujifilmFbJfiXml Mime = "application/vnd.fujifilm.fb.jfi+xml"

	// KMimeApplicationVndFujitsuOasys
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasys'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasys'
	KMimeApplicationVndFujitsuOasys Mime = "application/vnd.fujitsu.oasys"

	// KMimeApplicationVndFujitsuOasys2
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasys2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasys2'
	KMimeApplicationVndFujitsuOasys2 Mime = "application/vnd.fujitsu.oasys2"

	// KMimeApplicationVndFujitsuOasys3
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasys3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasys3'
	KMimeApplicationVndFujitsuOasys3 Mime = "application/vnd.fujitsu.oasys3"

	// KMimeApplicationVndFujitsuOasysgp
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasysgp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasysgp'
	KMimeApplicationVndFujitsuOasysgp Mime = "application/vnd.fujitsu.oasysgp"

	// KMimeApplicationVndFujitsuOasysprs
	//
	// English:
	//
	//  Application type 'vnd.fujitsu.oasysprs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujitsu.oasysprs'
	KMimeApplicationVndFujitsuOasysprs Mime = "application/vnd.fujitsu.oasysprs"

	// KMimeApplicationVndFujixeroxART4
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.ART4'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.ART4'
	KMimeApplicationVndFujixeroxART4 Mime = "application/vnd.fujixerox.ART4"

	// KMimeApplicationVndFujixeroxARTEX
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.ART-EX'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.ART-EX'
	KMimeApplicationVndFujixeroxARTEX Mime = "application/vnd.fujixerox.ART-EX"

	// KMimeApplicationVndFujixeroxDdd
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.ddd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.ddd'
	KMimeApplicationVndFujixeroxDdd Mime = "application/vnd.fujixerox.ddd"

	// KMimeApplicationVndFujixeroxDocuworks
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.docuworks'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.docuworks'
	KMimeApplicationVndFujixeroxDocuworks Mime = "application/vnd.fujixerox.docuworks"

	// KMimeApplicationVndFujixeroxDocuworksBinder
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.docuworks.binder'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.docuworks.binder'
	KMimeApplicationVndFujixeroxDocuworksBinder Mime = "application/vnd.fujixerox.docuworks.binder"

	// KMimeApplicationVndFujixeroxDocuworksContainer
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.docuworks.container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.docuworks.container'
	KMimeApplicationVndFujixeroxDocuworksContainer Mime = "application/vnd.fujixerox.docuworks.container"

	// KMimeApplicationVndFujixeroxHBPL
	//
	// English:
	//
	//  Application type 'vnd.fujixerox.HBPL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fujixerox.HBPL'
	KMimeApplicationVndFujixeroxHBPL Mime = "application/vnd.fujixerox.HBPL"

	// KMimeApplicationVndFutMisnet
	//
	// English:
	//
	//  Application type 'vnd.fut-misnet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fut-misnet'
	KMimeApplicationVndFutMisnet Mime = "application/vnd.fut-misnet"

	// KMimeApplicationVndFutoinCbor
	//
	// English:
	//
	//  Application type 'vnd.futoin+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.futoin+cbor'
	KMimeApplicationVndFutoinCbor Mime = "application/vnd.futoin+cbor"

	// KMimeApplicationVndFutoinJson
	//
	// English:
	//
	//  Application type 'vnd.futoin+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.futoin+json'
	KMimeApplicationVndFutoinJson Mime = "application/vnd.futoin+json"

	// KMimeApplicationVndFuzzysheet
	//
	// English:
	//
	//  Application type 'vnd.fuzzysheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.fuzzysheet'
	KMimeApplicationVndFuzzysheet Mime = "application/vnd.fuzzysheet"

	// KMimeApplicationVndGenomatixTuxedo
	//
	// English:
	//
	//  Application type 'vnd.genomatix.tuxedo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.genomatix.tuxedo'
	KMimeApplicationVndGenomatixTuxedo Mime = "application/vnd.genomatix.tuxedo"

	// KMimeApplicationVndGenozip
	//
	// English:
	//
	//  Application type 'vnd.genozip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.genozip'
	KMimeApplicationVndGenozip Mime = "application/vnd.genozip"

	// KMimeApplicationVndGenticsGrdJson
	//
	// English:
	//
	//  Application type 'vnd.gentics.grd+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gentics.grd+json'
	KMimeApplicationVndGenticsGrdJson Mime = "application/vnd.gentics.grd+json"

	// KMimeApplicationVndGeoJson
	//
	// English:
	//
	//  Application type 'vnd.geo+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geo+json'
	KMimeApplicationVndGeoJson Mime = "(OBSOLETED"

	// KMimeApplicationVndGeocubeXml
	//
	// English:
	//
	//  Application type 'vnd.geocube+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geocube+xml'
	KMimeApplicationVndGeocubeXml Mime = "(OBSOLETED"

	// KMimeApplicationVndGeogebraFile
	//
	// English:
	//
	//  Application type 'vnd.geogebra.file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geogebra.file'
	KMimeApplicationVndGeogebraFile Mime = "application/vnd.geogebra.file"

	// KMimeApplicationVndGeogebraSlides
	//
	// English:
	//
	//  Application type 'vnd.geogebra.slides'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geogebra.slides'
	KMimeApplicationVndGeogebraSlides Mime = "application/vnd.geogebra.slides"

	// KMimeApplicationVndGeogebraTool
	//
	// English:
	//
	//  Application type 'vnd.geogebra.tool'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geogebra.tool'
	KMimeApplicationVndGeogebraTool Mime = "application/vnd.geogebra.tool"

	// KMimeApplicationVndGeometryExplorer
	//
	// English:
	//
	//  Application type 'vnd.geometry-explorer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geometry-explorer'
	KMimeApplicationVndGeometryExplorer Mime = "application/vnd.geometry-explorer"

	// KMimeApplicationVndGeonext
	//
	// English:
	//
	//  Application type 'vnd.geonext'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geonext'
	KMimeApplicationVndGeonext Mime = "application/vnd.geonext"

	// KMimeApplicationVndGeoplan
	//
	// English:
	//
	//  Application type 'vnd.geoplan'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geoplan'
	KMimeApplicationVndGeoplan Mime = "application/vnd.geoplan"

	// KMimeApplicationVndGeospace
	//
	// English:
	//
	//  Application type 'vnd.geospace'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.geospace'
	KMimeApplicationVndGeospace Mime = "application/vnd.geospace"

	// KMimeApplicationVndGerber
	//
	// English:
	//
	//  Application type 'vnd.gerber'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gerber'
	KMimeApplicationVndGerber Mime = "application/vnd.gerber"

	// KMimeApplicationVndGlobalplatformCardContentMgt
	//
	// English:
	//
	//  Application type 'vnd.globalplatform.card-content-mgt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.globalplatform.card-content-mgt'
	KMimeApplicationVndGlobalplatformCardContentMgt Mime = "application/vnd.globalplatform.card-content-mgt"

	// KMimeApplicationVndGlobalplatformCardContentMgtResponse
	//
	// English:
	//
	//  Application type 'vnd.globalplatform.card-content-mgt-response'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.globalplatform.card-content-mgt-response'
	KMimeApplicationVndGlobalplatformCardContentMgtResponse Mime = "application/vnd.globalplatform.card-content-mgt-response"

	// KMimeApplicationVndGmx
	//
	// English:
	//
	//  Application type 'vnd.gmx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gmx'
	KMimeApplicationVndGmx Mime = "-"

	// KMimeApplicationVndGnuTalerExchangeJson
	//
	// English:
	//
	//  Application type 'vnd.gnu.taler.exchange+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gnu.taler.exchange+json'
	KMimeApplicationVndGnuTalerExchangeJson Mime = "application/vnd.gnu.taler.exchange+json"

	// KMimeApplicationVndGnuTalerMerchantJson
	//
	// English:
	//
	//  Application type 'vnd.gnu.taler.merchant+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gnu.taler.merchant+json'
	KMimeApplicationVndGnuTalerMerchantJson Mime = "application/vnd.gnu.taler.merchant+json"

	// KMimeApplicationVndGoogleEarthKmlXml
	//
	// English:
	//
	//  Application type 'vnd.google-earth.kml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.google-earth.kml+xml'
	KMimeApplicationVndGoogleEarthKmlXml Mime = "application/vnd.google-earth.kml+xml"

	// KMimeApplicationVndGoogleEarthKmz
	//
	// English:
	//
	//  Application type 'vnd.google-earth.kmz'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.google-earth.kmz'
	KMimeApplicationVndGoogleEarthKmz Mime = "application/vnd.google-earth.kmz"

	// KMimeApplicationVndGovSkEFormXml
	//
	// English:
	//
	//  Application type 'vnd.gov.sk.e-form+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gov.sk.e-form+xml'
	KMimeApplicationVndGovSkEFormXml Mime = "application/vnd.gov.sk.e-form+xml"

	// KMimeApplicationVndGovSkEFormZip
	//
	// English:
	//
	//  Application type 'vnd.gov.sk.e-form+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gov.sk.e-form+zip'
	KMimeApplicationVndGovSkEFormZip Mime = "application/vnd.gov.sk.e-form+zip"

	// KMimeApplicationVndGovSkXmldatacontainerXml
	//
	// English:
	//
	//  Application type 'vnd.gov.sk.xmldatacontainer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gov.sk.xmldatacontainer+xml'
	KMimeApplicationVndGovSkXmldatacontainerXml Mime = "application/vnd.gov.sk.xmldatacontainer+xml"

	// KMimeApplicationVndGrafeq
	//
	// English:
	//
	//  Application type 'vnd.grafeq'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.grafeq'
	KMimeApplicationVndGrafeq Mime = "application/vnd.grafeq"

	// KMimeApplicationVndGridmp
	//
	// English:
	//
	//  Application type 'vnd.gridmp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.gridmp'
	KMimeApplicationVndGridmp Mime = "application/vnd.gridmp"

	// KMimeApplicationVndGrooveAccount
	//
	// English:
	//
	//  Application type 'vnd.groove-account'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-account'
	KMimeApplicationVndGrooveAccount Mime = "application/vnd.groove-account"

	// KMimeApplicationVndGrooveHelp
	//
	// English:
	//
	//  Application type 'vnd.groove-help'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-help'
	KMimeApplicationVndGrooveHelp Mime = "application/vnd.groove-help"

	// KMimeApplicationVndGrooveIdentityMessage
	//
	// English:
	//
	//  Application type 'vnd.groove-identity-message'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-identity-message'
	KMimeApplicationVndGrooveIdentityMessage Mime = "application/vnd.groove-identity-message"

	// KMimeApplicationVndGrooveInjector
	//
	// English:
	//
	//  Application type 'vnd.groove-injector'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-injector'
	KMimeApplicationVndGrooveInjector Mime = "application/vnd.groove-injector"

	// KMimeApplicationVndGrooveToolMessage
	//
	// English:
	//
	//  Application type 'vnd.groove-tool-message'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-tool-message'
	KMimeApplicationVndGrooveToolMessage Mime = "application/vnd.groove-tool-message"

	// KMimeApplicationVndGrooveToolTemplate
	//
	// English:
	//
	//  Application type 'vnd.groove-tool-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-tool-template'
	KMimeApplicationVndGrooveToolTemplate Mime = "application/vnd.groove-tool-template"

	// KMimeApplicationVndGrooveVcard
	//
	// English:
	//
	//  Application type 'vnd.groove-vcard'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.groove-vcard'
	KMimeApplicationVndGrooveVcard Mime = "application/vnd.groove-vcard"

	// KMimeApplicationVndHalJson
	//
	// English:
	//
	//  Application type 'vnd.hal+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hal+json'
	KMimeApplicationVndHalJson Mime = "application/vnd.hal+json"

	// KMimeApplicationVndHalXml
	//
	// English:
	//
	//  Application type 'vnd.hal+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hal+xml'
	KMimeApplicationVndHalXml Mime = "application/vnd.hal+xml"

	// KMimeApplicationVndHandHeldEntertainmentXml
	//
	// English:
	//
	//  Application type 'vnd.HandHeld-Entertainment+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.HandHeld-Entertainment+xml'
	KMimeApplicationVndHandHeldEntertainmentXml Mime = "application/vnd.HandHeld-Entertainment+xml"

	// KMimeApplicationVndHbci
	//
	// English:
	//
	//  Application type 'vnd.hbci'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hbci'
	KMimeApplicationVndHbci Mime = "application/vnd.hbci"

	// KMimeApplicationVndHcJson
	//
	// English:
	//
	//  Application type 'vnd.hc+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hc+json'
	KMimeApplicationVndHcJson Mime = "application/vnd.hc+json"

	// KMimeApplicationVndHclBireports
	//
	// English:
	//
	//  Application type 'vnd.hcl-bireports'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hcl-bireports'
	KMimeApplicationVndHclBireports Mime = "application/vnd.hcl-bireports"

	// KMimeApplicationVndHdt
	//
	// English:
	//
	//  Application type 'vnd.hdt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hdt'
	KMimeApplicationVndHdt Mime = "application/vnd.hdt"

	// KMimeApplicationVndHerokuJson
	//
	// English:
	//
	//  Application type 'vnd.heroku+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.heroku+json'
	KMimeApplicationVndHerokuJson Mime = "application/vnd.heroku+json"

	// KMimeApplicationVndHheLessonPlayer
	//
	// English:
	//
	//  Application type 'vnd.hhe.lesson-player'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hhe.lesson-player'
	KMimeApplicationVndHheLessonPlayer Mime = "application/vnd.hhe.lesson-player"

	// KMimeApplicationVndHpHPGL
	//
	// English:
	//
	//  Application type 'vnd.hp-HPGL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-HPGL'
	KMimeApplicationVndHpHPGL Mime = "application/vnd.hp-HPGL"

	// KMimeApplicationVndHpHpid
	//
	// English:
	//
	//  Application type 'vnd.hp-hpid'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-hpid'
	KMimeApplicationVndHpHpid Mime = "application/vnd.hp-hpid"

	// KMimeApplicationVndHpHps
	//
	// English:
	//
	//  Application type 'vnd.hp-hps'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-hps'
	KMimeApplicationVndHpHps Mime = "application/vnd.hp-hps"

	// KMimeApplicationVndHpJlyt
	//
	// English:
	//
	//  Application type 'vnd.hp-jlyt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-jlyt'
	KMimeApplicationVndHpJlyt Mime = "application/vnd.hp-jlyt"

	// KMimeApplicationVndHpPCL
	//
	// English:
	//
	//  Application type 'vnd.hp-PCL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-PCL'
	KMimeApplicationVndHpPCL Mime = "application/vnd.hp-PCL"

	// KMimeApplicationVndHpPCLXL
	//
	// English:
	//
	//  Application type 'vnd.hp-PCLXL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hp-PCLXL'
	KMimeApplicationVndHpPCLXL Mime = "application/vnd.hp-PCLXL"

	// KMimeApplicationVndHttphone
	//
	// English:
	//
	//  Application type 'vnd.httphone'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.httphone'
	KMimeApplicationVndHttphone Mime = "application/vnd.httphone"

	// KMimeApplicationVndHydrostatixSofData
	//
	// English:
	//
	//  Application type 'vnd.hydrostatix.sof-data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hydrostatix.sof-data'
	KMimeApplicationVndHydrostatixSofData Mime = "application/vnd.hydrostatix.sof-data"

	// KMimeApplicationVndHyperItemJson
	//
	// English:
	//
	//  Application type 'vnd.hyper-item+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hyper-item+json'
	KMimeApplicationVndHyperItemJson Mime = "application/vnd.hyper-item+json"

	// KMimeApplicationVndHyperJson
	//
	// English:
	//
	//  Application type 'vnd.hyper+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hyper+json'
	KMimeApplicationVndHyperJson Mime = "application/vnd.hyper+json"

	// KMimeApplicationVndHyperdriveJson
	//
	// English:
	//
	//  Application type 'vnd.hyperdrive+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hyperdrive+json'
	KMimeApplicationVndHyperdriveJson Mime = "application/vnd.hyperdrive+json"

	// KMimeApplicationVndHzn3dCrossword
	//
	// English:
	//
	//  Application type 'vnd.hzn-3d-crossword'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.hzn-3d-crossword'
	KMimeApplicationVndHzn3dCrossword Mime = "application/vnd.hzn-3d-crossword"

	// KMimeApplicationVndIbmAfplinedata
	//
	// English:
	//
	//  Application type 'vnd.ibm.afplinedata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.afplinedata'
	KMimeApplicationVndIbmAfplinedata Mime = "(OBSOLETED"

	// KMimeApplicationVndIbmElectronicMedia
	//
	// English:
	//
	//  Application type 'vnd.ibm.electronic-media'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.electronic-media'
	KMimeApplicationVndIbmElectronicMedia Mime = "application/vnd.ibm.electronic-media"

	// KMimeApplicationVndIbmMiniPay
	//
	// English:
	//
	//  Application type 'vnd.ibm.MiniPay'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.MiniPay'
	KMimeApplicationVndIbmMiniPay Mime = "application/vnd.ibm.MiniPay"

	// KMimeApplicationVndIbmModcap
	//
	// English:
	//
	//  Application type 'vnd.ibm.modcap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.modcap'
	KMimeApplicationVndIbmModcap Mime = "(OBSOLETED"

	// KMimeApplicationVndIbmRightsManagement
	//
	// English:
	//
	//  Application type 'vnd.ibm.rights-management'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.rights-management'
	KMimeApplicationVndIbmRightsManagement Mime = "application/vnd.ibm.rights-management"

	// KMimeApplicationVndIbmSecureContainer
	//
	// English:
	//
	//  Application type 'vnd.ibm.secure-container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ibm.secure-container'
	KMimeApplicationVndIbmSecureContainer Mime = "application/vnd.ibm.secure-container"

	// KMimeApplicationVndIccprofile
	//
	// English:
	//
	//  Application type 'vnd.iccprofile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iccprofile'
	KMimeApplicationVndIccprofile Mime = "application/vnd.iccprofile"

	// KMimeApplicationVndIeee1905
	//
	// English:
	//
	//  Application type 'vnd.ieee.1905'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ieee.1905'
	KMimeApplicationVndIeee1905 Mime = "application/vnd.ieee.1905"

	// KMimeApplicationVndIgloader
	//
	// English:
	//
	//  Application type 'vnd.igloader'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.igloader'
	KMimeApplicationVndIgloader Mime = "application/vnd.igloader"

	// KMimeApplicationVndImagemeterFolderZip
	//
	// English:
	//
	//  Application type 'vnd.imagemeter.folder+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.imagemeter.folder+zip'
	KMimeApplicationVndImagemeterFolderZip Mime = "application/vnd.imagemeter.folder+zip"

	// KMimeApplicationVndImagemeterImageZip
	//
	// English:
	//
	//  Application type 'vnd.imagemeter.image+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.imagemeter.image+zip'
	KMimeApplicationVndImagemeterImageZip Mime = "application/vnd.imagemeter.image+zip"

	// KMimeApplicationVndImmervisionIvp
	//
	// English:
	//
	//  Application type 'vnd.immervision-ivp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.immervision-ivp'
	KMimeApplicationVndImmervisionIvp Mime = "application/vnd.immervision-ivp"

	// KMimeApplicationVndImmervisionIvu
	//
	// English:
	//
	//  Application type 'vnd.immervision-ivu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.immervision-ivu'
	KMimeApplicationVndImmervisionIvu Mime = "application/vnd.immervision-ivu"

	// KMimeApplicationVndImsImsccv1p1
	//
	// English:
	//
	//  Application type 'vnd.ims.imsccv1p1'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.imsccv1p1'
	KMimeApplicationVndImsImsccv1p1 Mime = "application/vnd.ims.imsccv1p1"

	// KMimeApplicationVndImsImsccv1p2
	//
	// English:
	//
	//  Application type 'vnd.ims.imsccv1p2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.imsccv1p2'
	KMimeApplicationVndImsImsccv1p2 Mime = "application/vnd.ims.imsccv1p2"

	// KMimeApplicationVndImsImsccv1p3
	//
	// English:
	//
	//  Application type 'vnd.ims.imsccv1p3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.imsccv1p3'
	KMimeApplicationVndImsImsccv1p3 Mime = "application/vnd.ims.imsccv1p3"

	// KMimeApplicationVndImsLisV2ResultJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lis.v2.result+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lis.v2.result+json'
	KMimeApplicationVndImsLisV2ResultJson Mime = "application/vnd.ims.lis.v2.result+json"

	// KMimeApplicationVndImsLtiV2ToolconsumerprofileJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolconsumerprofile+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolconsumerprofile+json'
	KMimeApplicationVndImsLtiV2ToolconsumerprofileJson Mime = "application/vnd.ims.lti.v2.toolconsumerprofile+json"

	// KMimeApplicationVndImsLtiV2ToolproxyIdJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolproxy.id+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolproxy.id+json'
	KMimeApplicationVndImsLtiV2ToolproxyIdJson Mime = "application/vnd.ims.lti.v2.toolproxy.id+json"

	// KMimeApplicationVndImsLtiV2ToolproxyJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolproxy+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolproxy+json'
	KMimeApplicationVndImsLtiV2ToolproxyJson Mime = "application/vnd.ims.lti.v2.toolproxy+json"

	// KMimeApplicationVndImsLtiV2ToolsettingsJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolsettings+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolsettings+json'
	KMimeApplicationVndImsLtiV2ToolsettingsJson Mime = "application/vnd.ims.lti.v2.toolsettings+json"

	// KMimeApplicationVndImsLtiV2ToolsettingsSimpleJson
	//
	// English:
	//
	//  Application type 'vnd.ims.lti.v2.toolsettings.simple+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ims.lti.v2.toolsettings.simple+json'
	KMimeApplicationVndImsLtiV2ToolsettingsSimpleJson Mime = "application/vnd.ims.lti.v2.toolsettings.simple+json"

	// KMimeApplicationVndInformedcontrolRmsXml
	//
	// English:
	//
	//  Application type 'vnd.informedcontrol.rms+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.informedcontrol.rms+xml'
	KMimeApplicationVndInformedcontrolRmsXml Mime = "application/vnd.informedcontrol.rms+xml"

	// KMimeApplicationVndInfotechProject
	//
	// English:
	//
	//  Application type 'vnd.infotech.project'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.infotech.project'
	KMimeApplicationVndInfotechProject Mime = "application/vnd.infotech.project"

	// KMimeApplicationVndInfotechProjectXml
	//
	// English:
	//
	//  Application type 'vnd.infotech.project+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.infotech.project+xml'
	KMimeApplicationVndInfotechProjectXml Mime = "application/vnd.infotech.project+xml"

	// KMimeApplicationVndInformixVisionary
	//
	// English:
	//
	//  Application type 'vnd.informix-visionary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.informix-visionary'
	KMimeApplicationVndInformixVisionary Mime = "(OBSOLETED"

	// KMimeApplicationVndInnopathWampNotification
	//
	// English:
	//
	//  Application type 'vnd.innopath.wamp.notification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.innopath.wamp.notification'
	KMimeApplicationVndInnopathWampNotification Mime = "application/vnd.innopath.wamp.notification"

	// KMimeApplicationVndInsorsIgm
	//
	// English:
	//
	//  Application type 'vnd.insors.igm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.insors.igm'
	KMimeApplicationVndInsorsIgm Mime = "application/vnd.insors.igm"

	// KMimeApplicationVndInterconFormnet
	//
	// English:
	//
	//  Application type 'vnd.intercon.formnet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intercon.formnet'
	KMimeApplicationVndInterconFormnet Mime = "application/vnd.intercon.formnet"

	// KMimeApplicationVndIntergeo
	//
	// English:
	//
	//  Application type 'vnd.intergeo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intergeo'
	KMimeApplicationVndIntergeo Mime = "application/vnd.intergeo"

	// KMimeApplicationVndIntertrustDigibox
	//
	// English:
	//
	//  Application type 'vnd.intertrust.digibox'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intertrust.digibox'
	KMimeApplicationVndIntertrustDigibox Mime = "application/vnd.intertrust.digibox"

	// KMimeApplicationVndIntertrustNncp
	//
	// English:
	//
	//  Application type 'vnd.intertrust.nncp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intertrust.nncp'
	KMimeApplicationVndIntertrustNncp Mime = "application/vnd.intertrust.nncp"

	// KMimeApplicationVndIntuQbo
	//
	// English:
	//
	//  Application type 'vnd.intu.qbo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intu.qbo'
	KMimeApplicationVndIntuQbo Mime = "application/vnd.intu.qbo"

	// KMimeApplicationVndIntuQfx
	//
	// English:
	//
	//  Application type 'vnd.intu.qfx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.intu.qfx'
	KMimeApplicationVndIntuQfx Mime = "application/vnd.intu.qfx"

	// KMimeApplicationVndIpldCar
	//
	// English:
	//
	//  Application type 'vnd.ipld.car'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ipld.car'
	KMimeApplicationVndIpldCar Mime = "application/vnd.ipld.car"

	// KMimeApplicationVndIpldRaw
	//
	// English:
	//
	//  Application type 'vnd.ipld.raw'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ipld.raw'
	KMimeApplicationVndIpldRaw Mime = "application/vnd.ipld.raw"

	// KMimeApplicationVndIptcG2CatalogitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.catalogitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.catalogitem+xml'
	KMimeApplicationVndIptcG2CatalogitemXml Mime = "application/vnd.iptc.g2.catalogitem+xml"

	// KMimeApplicationVndIptcG2ConceptitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.conceptitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.conceptitem+xml'
	KMimeApplicationVndIptcG2ConceptitemXml Mime = "application/vnd.iptc.g2.conceptitem+xml"

	// KMimeApplicationVndIptcG2KnowledgeitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.knowledgeitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.knowledgeitem+xml'
	KMimeApplicationVndIptcG2KnowledgeitemXml Mime = "application/vnd.iptc.g2.knowledgeitem+xml"

	// KMimeApplicationVndIptcG2NewsitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.newsitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.newsitem+xml'
	KMimeApplicationVndIptcG2NewsitemXml Mime = "application/vnd.iptc.g2.newsitem+xml"

	// KMimeApplicationVndIptcG2NewsmessageXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.newsmessage+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.newsmessage+xml'
	KMimeApplicationVndIptcG2NewsmessageXml Mime = "application/vnd.iptc.g2.newsmessage+xml"

	// KMimeApplicationVndIptcG2PackageitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.packageitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.packageitem+xml'
	KMimeApplicationVndIptcG2PackageitemXml Mime = "application/vnd.iptc.g2.packageitem+xml"

	// KMimeApplicationVndIptcG2PlanningitemXml
	//
	// English:
	//
	//  Application type 'vnd.iptc.g2.planningitem+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iptc.g2.planningitem+xml'
	KMimeApplicationVndIptcG2PlanningitemXml Mime = "application/vnd.iptc.g2.planningitem+xml"

	// KMimeApplicationVndIpunpluggedRcprofile
	//
	// English:
	//
	//  Application type 'vnd.ipunplugged.rcprofile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ipunplugged.rcprofile'
	KMimeApplicationVndIpunpluggedRcprofile Mime = "application/vnd.ipunplugged.rcprofile"

	// KMimeApplicationVndIrepositoryPackageXml
	//
	// English:
	//
	//  Application type 'vnd.irepository.package+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.irepository.package+xml'
	KMimeApplicationVndIrepositoryPackageXml Mime = "application/vnd.irepository.package+xml"

	// KMimeApplicationVndIsXpr
	//
	// English:
	//
	//  Application type 'vnd.is-xpr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.is-xpr'
	KMimeApplicationVndIsXpr Mime = "application/vnd.is-xpr"

	// KMimeApplicationVndIsacFcs
	//
	// English:
	//
	//  Application type 'vnd.isac.fcs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.isac.fcs'
	KMimeApplicationVndIsacFcs Mime = "application/vnd.isac.fcs"

	// KMimeApplicationVndJam
	//
	// English:
	//
	//  Application type 'vnd.jam'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jam'
	KMimeApplicationVndJam Mime = "application/vnd.jam"

	// KMimeApplicationVndIso1178310Zip
	//
	// English:
	//
	//  Application type 'vnd.iso11783-10+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.iso11783-10+zip'
	KMimeApplicationVndIso1178310Zip Mime = "application/vnd.iso11783-10+zip"

	// KMimeApplicationVndJapannetDirectoryService
	//
	// English:
	//
	//  Application type 'vnd.japannet-directory-service'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-directory-service'
	KMimeApplicationVndJapannetDirectoryService Mime = "application/vnd.japannet-directory-service"

	// KMimeApplicationVndJapannetJpnstoreWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-jpnstore-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-jpnstore-wakeup'
	KMimeApplicationVndJapannetJpnstoreWakeup Mime = "application/vnd.japannet-jpnstore-wakeup"

	// KMimeApplicationVndJapannetPaymentWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-payment-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-payment-wakeup'
	KMimeApplicationVndJapannetPaymentWakeup Mime = "application/vnd.japannet-payment-wakeup"

	// KMimeApplicationVndJapannetRegistration
	//
	// English:
	//
	//  Application type 'vnd.japannet-registration'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-registration'
	KMimeApplicationVndJapannetRegistration Mime = "application/vnd.japannet-registration"

	// KMimeApplicationVndJapannetRegistrationWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-registration-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-registration-wakeup'
	KMimeApplicationVndJapannetRegistrationWakeup Mime = "application/vnd.japannet-registration-wakeup"

	// KMimeApplicationVndJapannetSetstoreWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-setstore-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-setstore-wakeup'
	KMimeApplicationVndJapannetSetstoreWakeup Mime = "application/vnd.japannet-setstore-wakeup"

	// KMimeApplicationVndJapannetVerification
	//
	// English:
	//
	//  Application type 'vnd.japannet-verification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-verification'
	KMimeApplicationVndJapannetVerification Mime = "application/vnd.japannet-verification"

	// KMimeApplicationVndJapannetVerificationWakeup
	//
	// English:
	//
	//  Application type 'vnd.japannet-verification-wakeup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.japannet-verification-wakeup'
	KMimeApplicationVndJapannetVerificationWakeup Mime = "application/vnd.japannet-verification-wakeup"

	// KMimeApplicationVndJcpJavameMidletRms
	//
	// English:
	//
	//  Application type 'vnd.jcp.javame.midlet-rms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jcp.javame.midlet-rms'
	KMimeApplicationVndJcpJavameMidletRms Mime = "application/vnd.jcp.javame.midlet-rms"

	// KMimeApplicationVndJisp
	//
	// English:
	//
	//  Application type 'vnd.jisp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jisp'
	KMimeApplicationVndJisp Mime = "application/vnd.jisp"

	// KMimeApplicationVndJoostJodaArchive
	//
	// English:
	//
	//  Application type 'vnd.joost.joda-archive'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.joost.joda-archive'
	KMimeApplicationVndJoostJodaArchive Mime = "application/vnd.joost.joda-archive"

	// KMimeApplicationVndJskIsdnNgn
	//
	// English:
	//
	//  Application type 'vnd.jsk.isdn-ngn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.jsk.isdn-ngn'
	KMimeApplicationVndJskIsdnNgn Mime = "application/vnd.jsk.isdn-ngn"

	// KMimeApplicationVndKahootz
	//
	// English:
	//
	//  Application type 'vnd.kahootz'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kahootz'
	KMimeApplicationVndKahootz Mime = "application/vnd.kahootz"

	// KMimeApplicationVndKdeKarbon
	//
	// English:
	//
	//  Application type 'vnd.kde.karbon'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.karbon'
	KMimeApplicationVndKdeKarbon Mime = "application/vnd.kde.karbon"

	// KMimeApplicationVndKdeKchart
	//
	// English:
	//
	//  Application type 'vnd.kde.kchart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kchart'
	KMimeApplicationVndKdeKchart Mime = "application/vnd.kde.kchart"

	// KMimeApplicationVndKdeKformula
	//
	// English:
	//
	//  Application type 'vnd.kde.kformula'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kformula'
	KMimeApplicationVndKdeKformula Mime = "application/vnd.kde.kformula"

	// KMimeApplicationVndKdeKivio
	//
	// English:
	//
	//  Application type 'vnd.kde.kivio'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kivio'
	KMimeApplicationVndKdeKivio Mime = "application/vnd.kde.kivio"

	// KMimeApplicationVndKdeKontour
	//
	// English:
	//
	//  Application type 'vnd.kde.kontour'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kontour'
	KMimeApplicationVndKdeKontour Mime = "application/vnd.kde.kontour"

	// KMimeApplicationVndKdeKpresenter
	//
	// English:
	//
	//  Application type 'vnd.kde.kpresenter'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kpresenter'
	KMimeApplicationVndKdeKpresenter Mime = "application/vnd.kde.kpresenter"

	// KMimeApplicationVndKdeKspread
	//
	// English:
	//
	//  Application type 'vnd.kde.kspread'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kspread'
	KMimeApplicationVndKdeKspread Mime = "application/vnd.kde.kspread"

	// KMimeApplicationVndKdeKword
	//
	// English:
	//
	//  Application type 'vnd.kde.kword'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kde.kword'
	KMimeApplicationVndKdeKword Mime = "application/vnd.kde.kword"

	// KMimeApplicationVndKenameaapp
	//
	// English:
	//
	//  Application type 'vnd.kenameaapp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kenameaapp'
	KMimeApplicationVndKenameaapp Mime = "application/vnd.kenameaapp"

	// KMimeApplicationVndKidspiration
	//
	// English:
	//
	//  Application type 'vnd.kidspiration'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kidspiration'
	KMimeApplicationVndKidspiration Mime = "application/vnd.kidspiration"

	// KMimeApplicationVndKinar
	//
	// English:
	//
	//  Application type 'vnd.Kinar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Kinar'
	KMimeApplicationVndKinar Mime = "application/vnd.Kinar"

	// KMimeApplicationVndKoan
	//
	// English:
	//
	//  Application type 'vnd.koan'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.koan'
	KMimeApplicationVndKoan Mime = "application/vnd.koan"

	// KMimeApplicationVndKodakDescriptor
	//
	// English:
	//
	//  Application type 'vnd.kodak-descriptor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.kodak-descriptor'
	KMimeApplicationVndKodakDescriptor Mime = "application/vnd.kodak-descriptor"

	// KMimeApplicationVndLas
	//
	// English:
	//
	//  Application type 'vnd.las'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.las'
	KMimeApplicationVndLas Mime = "application/vnd.las"

	// KMimeApplicationVndLasLasJson
	//
	// English:
	//
	//  Application type 'vnd.las.las+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.las.las+json'
	KMimeApplicationVndLasLasJson Mime = "application/vnd.las.las+json"

	// KMimeApplicationVndLasLasXml
	//
	// English:
	//
	//  Application type 'vnd.las.las+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.las.las+xml'
	KMimeApplicationVndLasLasXml Mime = "application/vnd.las.las+xml"

	// KMimeApplicationVndLaszip
	//
	// English:
	//
	//  Application type 'vnd.laszip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.laszip'
	KMimeApplicationVndLaszip Mime = "application/vnd.laszip"

	// KMimeApplicationVndLeapJson
	//
	// English:
	//
	//  Application type 'vnd.leap+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.leap+json'
	KMimeApplicationVndLeapJson Mime = "application/vnd.leap+json"

	// KMimeApplicationVndLibertyRequestXml
	//
	// English:
	//
	//  Application type 'vnd.liberty-request+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.liberty-request+xml'
	KMimeApplicationVndLibertyRequestXml Mime = "application/vnd.liberty-request+xml"

	// KMimeApplicationVndLlamagraphicsLifeBalanceDesktop
	//
	// English:
	//
	//  Application type 'vnd.llamagraphics.life-balance.desktop'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.llamagraphics.life-balance.desktop'
	KMimeApplicationVndLlamagraphicsLifeBalanceDesktop Mime = "application/vnd.llamagraphics.life-balance.desktop"

	// KMimeApplicationVndLlamagraphicsLifeBalanceExchangeXml
	//
	// English:
	//
	//  Application type 'vnd.llamagraphics.life-balance.exchange+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.llamagraphics.life-balance.exchange+xml'
	KMimeApplicationVndLlamagraphicsLifeBalanceExchangeXml Mime = "application/vnd.llamagraphics.life-balance.exchange+xml"

	// KMimeApplicationVndLogipipeCircuitZip
	//
	// English:
	//
	//  Application type 'vnd.logipipe.circuit+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.logipipe.circuit+zip'
	KMimeApplicationVndLogipipeCircuitZip Mime = "application/vnd.logipipe.circuit+zip"

	// KMimeApplicationVndLoom
	//
	// English:
	//
	//  Application type 'vnd.loom'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.loom'
	KMimeApplicationVndLoom Mime = "application/vnd.loom"

	// KMimeApplicationVndLotus_1_2_3`
	//
	// English:
	//
	//  Application type 'vnd.lotus-1-2-3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-1-2-3'
	KMimeApplicationVndLotus_1_2_3 Mime = "application/vnd.lotus-1-2-3"

	// KMimeApplicationVndLotusApproach
	//
	// English:
	//
	//  Application type 'vnd.lotus-approach'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-approach'
	KMimeApplicationVndLotusApproach Mime = "application/vnd.lotus-approach"

	// KMimeApplicationVndLotusFreelance
	//
	// English:
	//
	//  Application type 'vnd.lotus-freelance'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-freelance'
	KMimeApplicationVndLotusFreelance Mime = "application/vnd.lotus-freelance"

	// KMimeApplicationVndLotusNotes
	//
	// English:
	//
	//  Application type 'vnd.lotus-notes'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-notes'
	KMimeApplicationVndLotusNotes Mime = "application/vnd.lotus-notes"

	// KMimeApplicationVndLotusOrganizer
	//
	// English:
	//
	//  Application type 'vnd.lotus-organizer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-organizer'
	KMimeApplicationVndLotusOrganizer Mime = "application/vnd.lotus-organizer"

	// KMimeApplicationVndLotusScreencam
	//
	// English:
	//
	//  Application type 'vnd.lotus-screencam'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-screencam'
	KMimeApplicationVndLotusScreencam Mime = "application/vnd.lotus-screencam"

	// KMimeApplicationVndLotusWordpro
	//
	// English:
	//
	//  Application type 'vnd.lotus-wordpro'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.lotus-wordpro'
	KMimeApplicationVndLotusWordpro Mime = "application/vnd.lotus-wordpro"

	// KMimeApplicationVndMacportsPortpkg
	//
	// English:
	//
	//  Application type 'vnd.macports.portpkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.macports.portpkg'
	KMimeApplicationVndMacportsPortpkg Mime = "application/vnd.macports.portpkg"

	// KMimeApplicationVndMapboxVectorTile
	//
	// English:
	//
	//  Application type 'vnd.mapbox-vector-tile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mapbox-vector-tile'
	KMimeApplicationVndMapboxVectorTile Mime = "application/vnd.mapbox-vector-tile"

	// KMimeApplicationVndMarlinDrmActiontokenXml
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.actiontoken+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.actiontoken+xml'
	KMimeApplicationVndMarlinDrmActiontokenXml Mime = "application/vnd.marlin.drm.actiontoken+xml"

	// KMimeApplicationVndMarlinDrmConftokenXml
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.conftoken+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.conftoken+xml'
	KMimeApplicationVndMarlinDrmConftokenXml Mime = "application/vnd.marlin.drm.conftoken+xml"

	// KMimeApplicationVndMarlinDrmLicenseXml
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.license+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.license+xml'
	KMimeApplicationVndMarlinDrmLicenseXml Mime = "application/vnd.marlin.drm.license+xml"

	// KMimeApplicationVndMarlinDrmMdcf
	//
	// English:
	//
	//  Application type 'vnd.marlin.drm.mdcf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.marlin.drm.mdcf'
	KMimeApplicationVndMarlinDrmMdcf Mime = "application/vnd.marlin.drm.mdcf"

	// KMimeApplicationVndMasonJson
	//
	// English:
	//
	//  Application type 'vnd.mason+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mason+json'
	KMimeApplicationVndMasonJson Mime = "application/vnd.mason+json"

	// KMimeApplicationVndMaxarArchive3tzZip
	//
	// English:
	//
	//  Application type 'vnd.maxar.archive.3tz+zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.maxar.archive.3tz+zip'
	KMimeApplicationVndMaxarArchive3tzZip Mime = "application/vnd.maxar.archive.3tz+zip"

	// KMimeApplicationVndMaxmindMaxmindDb
	//
	// English:
	//
	//  Application type 'vnd.maxmind.maxmind-db'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.maxmind.maxmind-db'
	KMimeApplicationVndMaxmindMaxmindDb Mime = "application/vnd.maxmind.maxmind-db"

	// KMimeApplicationVndMcd
	//
	// English:
	//
	//  Application type 'vnd.mcd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mcd'
	KMimeApplicationVndMcd Mime = "application/vnd.mcd"

	// KMimeApplicationVndMedcalcdata
	//
	// English:
	//
	//  Application type 'vnd.medcalcdata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.medcalcdata'
	KMimeApplicationVndMedcalcdata Mime = "application/vnd.medcalcdata"

	// KMimeApplicationVndMediastationCdkey
	//
	// English:
	//
	//  Application type 'vnd.mediastation.cdkey'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mediastation.cdkey'
	KMimeApplicationVndMediastationCdkey Mime = "application/vnd.mediastation.cdkey"

	// KMimeApplicationVndMeridianSlingshot
	//
	// English:
	//
	//  Application type 'vnd.meridian-slingshot'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.meridian-slingshot'
	KMimeApplicationVndMeridianSlingshot Mime = "application/vnd.meridian-slingshot"

	// KMimeApplicationVndMFER
	//
	// English:
	//
	//  Application type 'vnd.MFER'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.MFER'
	KMimeApplicationVndMFER Mime = "application/vnd.MFER"

	// KMimeApplicationVndMfmp
	//
	// English:
	//
	//  Application type 'vnd.mfmp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mfmp'
	KMimeApplicationVndMfmp Mime = "application/vnd.mfmp"

	// KMimeApplicationVndMicroJson
	//
	// English:
	//
	//  Application type 'vnd.micro+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.micro+json'
	KMimeApplicationVndMicroJson Mime = "application/vnd.micro+json"

	// KMimeApplicationVndMicrografxFlo
	//
	// English:
	//
	//  Application type 'vnd.micrografx.flo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.micrografx.flo'
	KMimeApplicationVndMicrografxFlo Mime = "application/vnd.micrografx.flo"

	// KMimeApplicationVndMicrografxIgx
	//
	// English:
	//
	//  Application type 'vnd.micrografx.igx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.micrografx.igx'
	KMimeApplicationVndMicrografxIgx Mime = "application/vnd.micrografx.igx"

	// KMimeApplicationVndMicrosoftPortableExecutable
	//
	// English:
	//
	//  Application type 'vnd.microsoft.portable-executable'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.microsoft.portable-executable'
	KMimeApplicationVndMicrosoftPortableExecutable Mime = "application/vnd.microsoft.portable-executable"

	// KMimeApplicationVndMicrosoftWindowsThumbnailCache
	//
	// English:
	//
	//  Application type 'vnd.microsoft.windows.thumbnail-cache'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.microsoft.windows.thumbnail-cache'
	KMimeApplicationVndMicrosoftWindowsThumbnailCache Mime = "application/vnd.microsoft.windows.thumbnail-cache"

	// KMimeApplicationVndMieleJson
	//
	// English:
	//
	//  Application type 'vnd.miele+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.miele+json'
	KMimeApplicationVndMieleJson Mime = "application/vnd.miele+json"

	// KMimeApplicationVndMif
	//
	// English:
	//
	//  Application type 'vnd.mif'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mif'
	KMimeApplicationVndMif Mime = "application/vnd.mif"

	// KMimeApplicationVndMinisoftHp3000Save
	//
	// English:
	//
	//  Application type 'vnd.minisoft-hp3000-save'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.minisoft-hp3000-save'
	KMimeApplicationVndMinisoftHp3000Save Mime = "application/vnd.minisoft-hp3000-save"

	// KMimeApplicationVndMitsubishiMistyGuardTrustweb
	//
	// English:
	//
	//  Application type 'vnd.mitsubishi.misty-guard.trustweb'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mitsubishi.misty-guard.trustweb'
	KMimeApplicationVndMitsubishiMistyGuardTrustweb Mime = "application/vnd.mitsubishi.misty-guard.trustweb"

	// KMimeApplicationVndMobiusDAF
	//
	// English:
	//
	//  Application type 'vnd.Mobius.DAF'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.DAF'
	KMimeApplicationVndMobiusDAF Mime = "application/vnd.Mobius.DAF"

	// KMimeApplicationVndMobiusDIS
	//
	// English:
	//
	//  Application type 'vnd.Mobius.DIS'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.DIS'
	KMimeApplicationVndMobiusDIS Mime = "application/vnd.Mobius.DIS"

	// KMimeApplicationVndMobiusMBK
	//
	// English:
	//
	//  Application type 'vnd.Mobius.MBK'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.MBK'
	KMimeApplicationVndMobiusMBK Mime = "application/vnd.Mobius.MBK"

	// KMimeApplicationVndMobiusMQY
	//
	// English:
	//
	//  Application type 'vnd.Mobius.MQY'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.MQY'
	KMimeApplicationVndMobiusMQY Mime = "application/vnd.Mobius.MQY"

	// KMimeApplicationVndMobiusMSL
	//
	// English:
	//
	//  Application type 'vnd.Mobius.MSL'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.MSL'
	KMimeApplicationVndMobiusMSL Mime = "application/vnd.Mobius.MSL"

	// KMimeApplicationVndMobiusPLC
	//
	// English:
	//
	//  Application type 'vnd.Mobius.PLC'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.PLC'
	KMimeApplicationVndMobiusPLC Mime = "application/vnd.Mobius.PLC"

	// KMimeApplicationVndMobiusTXF
	//
	// English:
	//
	//  Application type 'vnd.Mobius.TXF'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Mobius.TXF'
	KMimeApplicationVndMobiusTXF Mime = "application/vnd.Mobius.TXF"

	// KMimeApplicationVndMophunApplication
	//
	// English:
	//
	//  Application type 'vnd.mophun.application'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mophun.application'
	KMimeApplicationVndMophunApplication Mime = "application/vnd.mophun.application"

	// KMimeApplicationVndMophunCertificate
	//
	// English:
	//
	//  Application type 'vnd.mophun.certificate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mophun.certificate'
	KMimeApplicationVndMophunCertificate Mime = "application/vnd.mophun.certificate"

	// KMimeApplicationVndMotorolaFlexsuite
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite'
	KMimeApplicationVndMotorolaFlexsuite Mime = "application/vnd.motorola.flexsuite"

	// KMimeApplicationVndMotorolaFlexsuiteAdsi
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.adsi'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.adsi'
	KMimeApplicationVndMotorolaFlexsuiteAdsi Mime = "application/vnd.motorola.flexsuite.adsi"

	// KMimeApplicationVndMotorolaFlexsuiteFis
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.fis'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.fis'
	KMimeApplicationVndMotorolaFlexsuiteFis Mime = "application/vnd.motorola.flexsuite.fis"

	// KMimeApplicationVndMotorolaFlexsuiteGotap
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.gotap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.gotap'
	KMimeApplicationVndMotorolaFlexsuiteGotap Mime = "application/vnd.motorola.flexsuite.gotap"

	// KMimeApplicationVndMotorolaFlexsuiteKmr
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.kmr'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.kmr'
	KMimeApplicationVndMotorolaFlexsuiteKmr Mime = "application/vnd.motorola.flexsuite.kmr"

	// KMimeApplicationVndMotorolaFlexsuiteTtc
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.ttc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.ttc'
	KMimeApplicationVndMotorolaFlexsuiteTtc Mime = "application/vnd.motorola.flexsuite.ttc"

	// KMimeApplicationVndMotorolaFlexsuiteWem
	//
	// English:
	//
	//  Application type 'vnd.motorola.flexsuite.wem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.flexsuite.wem'
	KMimeApplicationVndMotorolaFlexsuiteWem Mime = "application/vnd.motorola.flexsuite.wem"

	// KMimeApplicationVndMotorolaIprm
	//
	// English:
	//
	//  Application type 'vnd.motorola.iprm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.motorola.iprm'
	KMimeApplicationVndMotorolaIprm Mime = "application/vnd.motorola.iprm"

	// KMimeApplicationVndMozillaXulXml
	//
	// English:
	//
	//  Application type 'vnd.mozilla.xul+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mozilla.xul+xml'
	KMimeApplicationVndMozillaXulXml Mime = "application/vnd.mozilla.xul+xml"

	// KMimeApplicationVndMsArtgalry
	//
	// English:
	//
	//  Application type 'vnd.ms-artgalry'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-artgalry'
	KMimeApplicationVndMsArtgalry Mime = "application/vnd.ms-artgalry"

	// KMimeApplicationVndMsAsf
	//
	// English:
	//
	//  Application type 'vnd.ms-asf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-asf'
	KMimeApplicationVndMsAsf Mime = "application/vnd.ms-asf"

	// KMimeApplicationVndMsCabCompressed
	//
	// English:
	//
	//  Application type 'vnd.ms-cab-compressed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-cab-compressed'
	KMimeApplicationVndMsCabCompressed Mime = "application/vnd.ms-cab-compressed"

	// KMimeApplicationVndMs3mfdocument
	//
	// English:
	//
	//  Application type 'vnd.ms-3mfdocument'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-3mfdocument'
	KMimeApplicationVndMs3mfdocument Mime = "application/vnd.ms-3mfdocument"

	// KMimeApplicationVndMsExcel
	//
	// English:
	//
	//  Application type 'vnd.ms-excel'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel'
	KMimeApplicationVndMsExcel Mime = "application/vnd.ms-excel"

	// KMimeApplicationVndMsExcelAddinMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.addin.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.addin.macroEnabled.12'
	KMimeApplicationVndMsExcelAddinMacroEnabled12 Mime = "application/vnd.ms-excel.addin.macroEnabled.12"

	// KMimeApplicationVndMsExcelSheetBinaryMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.sheet.binary.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.sheet.binary.macroEnabled.12'
	KMimeApplicationVndMsExcelSheetBinaryMacroEnabled12 Mime = "application/vnd.ms-excel.sheet.binary.macroEnabled.12"

	// KMimeApplicationVndMsExcelSheetMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.sheet.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.sheet.macroEnabled.12'
	KMimeApplicationVndMsExcelSheetMacroEnabled12 Mime = "application/vnd.ms-excel.sheet.macroEnabled.12"

	// KMimeApplicationVndMsExcelTemplateMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-excel.template.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-excel.template.macroEnabled.12'
	KMimeApplicationVndMsExcelTemplateMacroEnabled12 Mime = "application/vnd.ms-excel.template.macroEnabled.12"

	// KMimeApplicationVndMsFontobject
	//
	// English:
	//
	//  Application type 'vnd.ms-fontobject'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-fontobject'
	KMimeApplicationVndMsFontobject Mime = "application/vnd.ms-fontobject"

	// KMimeApplicationVndMsHtmlhelp
	//
	// English:
	//
	//  Application type 'vnd.ms-htmlhelp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-htmlhelp'
	KMimeApplicationVndMsHtmlhelp Mime = "application/vnd.ms-htmlhelp"

	// KMimeApplicationVndMsIms
	//
	// English:
	//
	//  Application type 'vnd.ms-ims'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-ims'
	KMimeApplicationVndMsIms Mime = "application/vnd.ms-ims"

	// KMimeApplicationVndMsLrm
	//
	// English:
	//
	//  Application type 'vnd.ms-lrm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-lrm'
	KMimeApplicationVndMsLrm Mime = "application/vnd.ms-lrm"

	// KMimeApplicationVndMsOfficeActiveXXml
	//
	// English:
	//
	//  Application type 'vnd.ms-office.activeX+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-office.activeX+xml'
	KMimeApplicationVndMsOfficeActiveXXml Mime = "application/vnd.ms-office.activeX+xml"

	// KMimeApplicationVndMsOfficetheme
	//
	// English:
	//
	//  Application type 'vnd.ms-officetheme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-officetheme'
	KMimeApplicationVndMsOfficetheme Mime = "application/vnd.ms-officetheme"

	// KMimeApplicationVndMsPlayreadyInitiatorXml
	//
	// English:
	//
	//  Application type 'vnd.ms-playready.initiator+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-playready.initiator+xml'
	KMimeApplicationVndMsPlayreadyInitiatorXml Mime = "application/vnd.ms-playready.initiator+xml"

	// KMimeApplicationVndMsPowerpoint
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint'
	KMimeApplicationVndMsPowerpoint Mime = "application/vnd.ms-powerpoint"

	// KMimeApplicationVndMsPowerpointAddinMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.addin.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.addin.macroEnabled.12'
	KMimeApplicationVndMsPowerpointAddinMacroEnabled12 Mime = "application/vnd.ms-powerpoint.addin.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointPresentationMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.presentation.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.presentation.macroEnabled.12'
	KMimeApplicationVndMsPowerpointPresentationMacroEnabled12 Mime = "application/vnd.ms-powerpoint.presentation.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointSlideMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.slide.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.slide.macroEnabled.12'
	KMimeApplicationVndMsPowerpointSlideMacroEnabled12 Mime = "application/vnd.ms-powerpoint.slide.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointSlideshowMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.slideshow.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.slideshow.macroEnabled.12'
	KMimeApplicationVndMsPowerpointSlideshowMacroEnabled12 Mime = "application/vnd.ms-powerpoint.slideshow.macroEnabled.12"

	// KMimeApplicationVndMsPowerpointTemplateMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-powerpoint.template.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-powerpoint.template.macroEnabled.12'
	KMimeApplicationVndMsPowerpointTemplateMacroEnabled12 Mime = "application/vnd.ms-powerpoint.template.macroEnabled.12"

	// KMimeApplicationVndMsPrintDeviceCapabilitiesXml
	//
	// English:
	//
	//  Application type 'vnd.ms-PrintDeviceCapabilities+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-PrintDeviceCapabilities+xml'
	KMimeApplicationVndMsPrintDeviceCapabilitiesXml Mime = "application/vnd.ms-PrintDeviceCapabilities+xml"

	// KMimeApplicationVndMsPrintSchemaTicketXml
	//
	// English:
	//
	//  Application type 'vnd.ms-PrintSchemaTicket+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-PrintSchemaTicket+xml'
	KMimeApplicationVndMsPrintSchemaTicketXml Mime = "application/vnd.ms-PrintSchemaTicket+xml"

	// KMimeApplicationVndMsProject
	//
	// English:
	//
	//  Application type 'vnd.ms-project'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-project'
	KMimeApplicationVndMsProject Mime = "application/vnd.ms-project"

	// KMimeApplicationVndMsTnef
	//
	// English:
	//
	//  Application type 'vnd.ms-tnef'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-tnef'
	KMimeApplicationVndMsTnef Mime = "application/vnd.ms-tnef"

	// KMimeApplicationVndMsWindowsDevicepairing
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.devicepairing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.devicepairing'
	KMimeApplicationVndMsWindowsDevicepairing Mime = "application/vnd.ms-windows.devicepairing"

	// KMimeApplicationVndMsWindowsNwprintingOob
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.nwprinting.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.nwprinting.oob'
	KMimeApplicationVndMsWindowsNwprintingOob Mime = "application/vnd.ms-windows.nwprinting.oob"

	// KMimeApplicationVndMsWindowsPrinterpairing
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.printerpairing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.printerpairing'
	KMimeApplicationVndMsWindowsPrinterpairing Mime = "application/vnd.ms-windows.printerpairing"

	// KMimeApplicationVndMsWindowsWsdOob
	//
	// English:
	//
	//  Application type 'vnd.ms-windows.wsd.oob'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-windows.wsd.oob'
	KMimeApplicationVndMsWindowsWsdOob Mime = "application/vnd.ms-windows.wsd.oob"

	// KMimeApplicationVndMsWmdrmLicChlgReq
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.lic-chlg-req'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.lic-chlg-req'
	KMimeApplicationVndMsWmdrmLicChlgReq Mime = "application/vnd.ms-wmdrm.lic-chlg-req"

	// KMimeApplicationVndMsWmdrmLicResp
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.lic-resp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.lic-resp'
	KMimeApplicationVndMsWmdrmLicResp Mime = "application/vnd.ms-wmdrm.lic-resp"

	// KMimeApplicationVndMsWmdrmMeterChlgReq
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.meter-chlg-req'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.meter-chlg-req'
	KMimeApplicationVndMsWmdrmMeterChlgReq Mime = "application/vnd.ms-wmdrm.meter-chlg-req"

	// KMimeApplicationVndMsWmdrmMeterResp
	//
	// English:
	//
	//  Application type 'vnd.ms-wmdrm.meter-resp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wmdrm.meter-resp'
	KMimeApplicationVndMsWmdrmMeterResp Mime = "application/vnd.ms-wmdrm.meter-resp"

	// KMimeApplicationVndMsWordDocumentMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-word.document.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-word.document.macroEnabled.12'
	KMimeApplicationVndMsWordDocumentMacroEnabled12 Mime = "application/vnd.ms-word.document.macroEnabled.12"

	// KMimeApplicationVndMsWordTemplateMacroEnabled12
	//
	// English:
	//
	//  Application type 'vnd.ms-word.template.macroEnabled.12'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-word.template.macroEnabled.12'
	KMimeApplicationVndMsWordTemplateMacroEnabled12 Mime = "application/vnd.ms-word.template.macroEnabled.12"

	// KMimeApplicationVndMsWorks
	//
	// English:
	//
	//  Application type 'vnd.ms-works'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-works'
	KMimeApplicationVndMsWorks Mime = "application/vnd.ms-works"

	// KMimeApplicationVndMsWpl
	//
	// English:
	//
	//  Application type 'vnd.ms-wpl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-wpl'
	KMimeApplicationVndMsWpl Mime = "application/vnd.ms-wpl"

	// KMimeApplicationVndMsXpsdocument
	//
	// English:
	//
	//  Application type 'vnd.ms-xpsdocument'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ms-xpsdocument'
	KMimeApplicationVndMsXpsdocument Mime = "application/vnd.ms-xpsdocument"

	// KMimeApplicationVndMsaDiskImage
	//
	// English:
	//
	//  Application type 'vnd.msa-disk-image'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.msa-disk-image'
	KMimeApplicationVndMsaDiskImage Mime = "application/vnd.msa-disk-image"

	// KMimeApplicationVndMseq
	//
	// English:
	//
	//  Application type 'vnd.mseq'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mseq'
	KMimeApplicationVndMseq Mime = "application/vnd.mseq"

	// KMimeApplicationVndMsign
	//
	// English:
	//
	//  Application type 'vnd.msign'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.msign'
	KMimeApplicationVndMsign Mime = "application/vnd.msign"

	// KMimeApplicationVndMultiadCreator
	//
	// English:
	//
	//  Application type 'vnd.multiad.creator'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.multiad.creator'
	KMimeApplicationVndMultiadCreator Mime = "application/vnd.multiad.creator"

	// KMimeApplicationVndMultiadCreatorCif
	//
	// English:
	//
	//  Application type 'vnd.multiad.creator.cif'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.multiad.creator.cif'
	KMimeApplicationVndMultiadCreatorCif Mime = "application/vnd.multiad.creator.cif"

	// KMimeApplicationVndMusician
	//
	// English:
	//
	//  Application type 'vnd.musician'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.musician'
	KMimeApplicationVndMusician Mime = "application/vnd.musician"

	// KMimeApplicationVndMusicNiff
	//
	// English:
	//
	//  Application type 'vnd.music-niff'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.music-niff'
	KMimeApplicationVndMusicNiff Mime = "application/vnd.music-niff"

	// KMimeApplicationVndMuveeStyle
	//
	// English:
	//
	//  Application type 'vnd.muvee.style'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.muvee.style'
	KMimeApplicationVndMuveeStyle Mime = "application/vnd.muvee.style"

	// KMimeApplicationVndMynfc
	//
	// English:
	//
	//  Application type 'vnd.mynfc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.mynfc'
	KMimeApplicationVndMynfc Mime = "application/vnd.mynfc"

	// KMimeApplicationVndNacamarYbridJson
	//
	// English:
	//
	//  Application type 'vnd.nacamar.ybrid+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nacamar.ybrid+json'
	KMimeApplicationVndNacamarYbridJson Mime = "application/vnd.nacamar.ybrid+json"

	// KMimeApplicationVndNcdControl
	//
	// English:
	//
	//  Application type 'vnd.ncd.control'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ncd.control'
	KMimeApplicationVndNcdControl Mime = "application/vnd.ncd.control"

	// KMimeApplicationVndNcdReference
	//
	// English:
	//
	//  Application type 'vnd.ncd.reference'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ncd.reference'
	KMimeApplicationVndNcdReference Mime = "application/vnd.ncd.reference"

	// KMimeApplicationVndNearstInvJson
	//
	// English:
	//
	//  Application type 'vnd.nearst.inv+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nearst.inv+json'
	KMimeApplicationVndNearstInvJson Mime = "application/vnd.nearst.inv+json"

	// KMimeApplicationVndNebumindLine
	//
	// English:
	//
	//  Application type 'vnd.nebumind.line'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nebumind.line'
	KMimeApplicationVndNebumindLine Mime = "application/vnd.nebumind.line"

	// KMimeApplicationVndNervana
	//
	// English:
	//
	//  Application type 'vnd.nervana'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nervana'
	KMimeApplicationVndNervana Mime = "application/vnd.nervana"

	// KMimeApplicationVndNetfpx
	//
	// English:
	//
	//  Application type 'vnd.netfpx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.netfpx'
	KMimeApplicationVndNetfpx Mime = "application/vnd.netfpx"

	// KMimeApplicationVndNeurolanguageNlu
	//
	// English:
	//
	//  Application type 'vnd.neurolanguage.nlu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.neurolanguage.nlu'
	KMimeApplicationVndNeurolanguageNlu Mime = "application/vnd.neurolanguage.nlu"

	// KMimeApplicationVndNimn
	//
	// English:
	//
	//  Application type 'vnd.nimn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nimn'
	KMimeApplicationVndNimn Mime = "application/vnd.nimn"

	// KMimeApplicationVndNintendoSnesRom
	//
	// English:
	//
	//  Application type 'vnd.nintendo.snes.rom'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nintendo.snes.rom'
	KMimeApplicationVndNintendoSnesRom Mime = "application/vnd.nintendo.snes.rom"

	// KMimeApplicationVndNintendoNitroRom
	//
	// English:
	//
	//  Application type 'vnd.nintendo.nitro.rom'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nintendo.nitro.rom'
	KMimeApplicationVndNintendoNitroRom Mime = "application/vnd.nintendo.nitro.rom"

	// KMimeApplicationVndNitf
	//
	// English:
	//
	//  Application type 'vnd.nitf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nitf'
	KMimeApplicationVndNitf Mime = "application/vnd.nitf"

	// KMimeApplicationVndNoblenetDirectory
	//
	// English:
	//
	//  Application type 'vnd.noblenet-directory'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.noblenet-directory'
	KMimeApplicationVndNoblenetDirectory Mime = "application/vnd.noblenet-directory"

	// KMimeApplicationVndNoblenetSealer
	//
	// English:
	//
	//  Application type 'vnd.noblenet-sealer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.noblenet-sealer'
	KMimeApplicationVndNoblenetSealer Mime = "application/vnd.noblenet-sealer"

	// KMimeApplicationVndNoblenetWeb
	//
	// English:
	//
	//  Application type 'vnd.noblenet-web'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.noblenet-web'
	KMimeApplicationVndNoblenetWeb Mime = "application/vnd.noblenet-web"

	// KMimeApplicationVndNokiaCatalogs
	//
	// English:
	//
	//  Application type 'vnd.nokia.catalogs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.catalogs'
	KMimeApplicationVndNokiaCatalogs Mime = "application/vnd.nokia.catalogs"

	// KMimeApplicationVndNokiaConmlWbxml
	//
	// English:
	//
	//  Application type 'vnd.nokia.conml+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.conml+wbxml'
	KMimeApplicationVndNokiaConmlWbxml Mime = "application/vnd.nokia.conml+wbxml"

	// KMimeApplicationVndNokiaConmlXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.conml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.conml+xml'
	KMimeApplicationVndNokiaConmlXml Mime = "application/vnd.nokia.conml+xml"

	// KMimeApplicationVndNokiaIptvConfigXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.iptv.config+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.iptv.config+xml'
	KMimeApplicationVndNokiaIptvConfigXml Mime = "application/vnd.nokia.iptv.config+xml"

	// KMimeApplicationVndNokiaISDSRadioPresets
	//
	// English:
	//
	//  Application type 'vnd.nokia.iSDS-radio-presets'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.iSDS-radio-presets'
	KMimeApplicationVndNokiaISDSRadioPresets Mime = "application/vnd.nokia.iSDS-radio-presets"

	// KMimeApplicationVndNokiaLandmarkWbxml
	//
	// English:
	//
	//  Application type 'vnd.nokia.landmark+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.landmark+wbxml'
	KMimeApplicationVndNokiaLandmarkWbxml Mime = "application/vnd.nokia.landmark+wbxml"

	// KMimeApplicationVndNokiaLandmarkXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.landmark+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.landmark+xml'
	KMimeApplicationVndNokiaLandmarkXml Mime = "application/vnd.nokia.landmark+xml"

	// KMimeApplicationVndNokiaLandmarkcollectionXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.landmarkcollection+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.landmarkcollection+xml'
	KMimeApplicationVndNokiaLandmarkcollectionXml Mime = "application/vnd.nokia.landmarkcollection+xml"

	// KMimeApplicationVndNokiaNcd
	//
	// English:
	//
	//  Application type 'vnd.nokia.ncd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.ncd'
	KMimeApplicationVndNokiaNcd Mime = "application/vnd.nokia.ncd"

	// KMimeApplicationVndNokiaNGageAcXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.n-gage.ac+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.n-gage.ac+xml'
	KMimeApplicationVndNokiaNGageAcXml Mime = "application/vnd.nokia.n-gage.ac+xml"

	// KMimeApplicationVndNokiaNGageData
	//
	// English:
	//
	//  Application type 'vnd.nokia.n-gage.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.n-gage.data'
	KMimeApplicationVndNokiaNGageData Mime = "application/vnd.nokia.n-gage.data"

	// KMimeApplicationVndNokiaNGageSymbianInstall
	//
	// English:
	//
	//  Application type 'vnd.nokia.n-gage.symbian.install'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.n-gage.symbian.install'
	KMimeApplicationVndNokiaNGageSymbianInstall Mime = "(OBSOLETE;"

	// KMimeApplicationVndNokiaPcdWbxml
	//
	// English:
	//
	//  Application type 'vnd.nokia.pcd+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.pcd+wbxml'
	KMimeApplicationVndNokiaPcdWbxml Mime = "application/vnd.nokia.pcd+wbxml"

	// KMimeApplicationVndNokiaPcdXml
	//
	// English:
	//
	//  Application type 'vnd.nokia.pcd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.pcd+xml'
	KMimeApplicationVndNokiaPcdXml Mime = "application/vnd.nokia.pcd+xml"

	// KMimeApplicationVndNokiaRadioPreset
	//
	// English:
	//
	//  Application type 'vnd.nokia.radio-preset'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.radio-preset'
	KMimeApplicationVndNokiaRadioPreset Mime = "application/vnd.nokia.radio-preset"

	// KMimeApplicationVndNokiaRadioPresets
	//
	// English:
	//
	//  Application type 'vnd.nokia.radio-presets'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.nokia.radio-presets'
	KMimeApplicationVndNokiaRadioPresets Mime = "application/vnd.nokia.radio-presets"

	// KMimeApplicationVndNovadigmEDM
	//
	// English:
	//
	//  Application type 'vnd.novadigm.EDM'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.novadigm.EDM'
	KMimeApplicationVndNovadigmEDM Mime = "application/vnd.novadigm.EDM"

	// KMimeApplicationVndNovadigmEDX
	//
	// English:
	//
	//  Application type 'vnd.novadigm.EDX'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.novadigm.EDX'
	KMimeApplicationVndNovadigmEDX Mime = "application/vnd.novadigm.EDX"

	// KMimeApplicationVndNovadigmEXT
	//
	// English:
	//
	//  Application type 'vnd.novadigm.EXT'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.novadigm.EXT'
	KMimeApplicationVndNovadigmEXT Mime = "application/vnd.novadigm.EXT"

	// KMimeApplicationVndNttLocalContentShare
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.content-share'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.content-share'
	KMimeApplicationVndNttLocalContentShare Mime = "application/vnd.ntt-local.content-share"

	// KMimeApplicationVndNttLocalFileTransfer
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.file-transfer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.file-transfer'
	KMimeApplicationVndNttLocalFileTransfer Mime = "application/vnd.ntt-local.file-transfer"

	// KMimeApplicationVndNttLocalOgwRemoteAccess
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.ogw_remote-access'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.ogw_remote-access'
	KMimeApplicationVndNttLocalOgwRemoteAccess Mime = "application/vnd.ntt-local.ogw_remote-access"

	// KMimeApplicationVndNttLocalSipTaRemote
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.sip-ta_remote'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.sip-ta_remote'
	KMimeApplicationVndNttLocalSipTaRemote Mime = "application/vnd.ntt-local.sip-ta_remote"

	// KMimeApplicationVndNttLocalSipTaTcpStream
	//
	// English:
	//
	//  Application type 'vnd.ntt-local.sip-ta_tcp_stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ntt-local.sip-ta_tcp_stream'
	KMimeApplicationVndNttLocalSipTaTcpStream Mime = "application/vnd.ntt-local.sip-ta_tcp_stream"

	// KMimeApplicationVndOasisOpendocumentChart
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.chart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.chart'
	KMimeApplicationVndOasisOpendocumentChart Mime = "application/vnd.oasis.opendocument.chart"

	// KMimeApplicationVndOasisOpendocumentChartTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.chart-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.chart-template'
	KMimeApplicationVndOasisOpendocumentChartTemplate Mime = "application/vnd.oasis.opendocument.chart-template"

	// KMimeApplicationVndOasisOpendocumentDatabase
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.database'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.database'
	KMimeApplicationVndOasisOpendocumentDatabase Mime = "application/vnd.oasis.opendocument.database"

	// KMimeApplicationVndOasisOpendocumentFormula
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.formula'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.formula'
	KMimeApplicationVndOasisOpendocumentFormula Mime = "application/vnd.oasis.opendocument.formula"

	// KMimeApplicationVndOasisOpendocumentFormulaTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.formula-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.formula-template'
	KMimeApplicationVndOasisOpendocumentFormulaTemplate Mime = "application/vnd.oasis.opendocument.formula-template"

	// KMimeApplicationVndOasisOpendocumentGraphics
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.graphics'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.graphics'
	KMimeApplicationVndOasisOpendocumentGraphics Mime = "application/vnd.oasis.opendocument.graphics"

	// KMimeApplicationVndOasisOpendocumentGraphicsTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.graphics-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.graphics-template'
	KMimeApplicationVndOasisOpendocumentGraphicsTemplate Mime = "application/vnd.oasis.opendocument.graphics-template"

	// KMimeApplicationVndOasisOpendocumentImage
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.image'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.image'
	KMimeApplicationVndOasisOpendocumentImage Mime = "application/vnd.oasis.opendocument.image"

	// KMimeApplicationVndOasisOpendocumentImageTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.image-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.image-template'
	KMimeApplicationVndOasisOpendocumentImageTemplate Mime = "application/vnd.oasis.opendocument.image-template"

	// KMimeApplicationVndOasisOpendocumentPresentation
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.presentation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.presentation'
	KMimeApplicationVndOasisOpendocumentPresentation Mime = "application/vnd.oasis.opendocument.presentation"

	// KMimeApplicationVndOasisOpendocumentPresentationTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.presentation-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.presentation-template'
	KMimeApplicationVndOasisOpendocumentPresentationTemplate Mime = "application/vnd.oasis.opendocument.presentation-template"

	// KMimeApplicationVndOasisOpendocumentSpreadsheet
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.spreadsheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.spreadsheet'
	KMimeApplicationVndOasisOpendocumentSpreadsheet Mime = "application/vnd.oasis.opendocument.spreadsheet"

	// KMimeApplicationVndOasisOpendocumentSpreadsheetTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.spreadsheet-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.spreadsheet-template'
	KMimeApplicationVndOasisOpendocumentSpreadsheetTemplate Mime = "application/vnd.oasis.opendocument.spreadsheet-template"

	// KMimeApplicationVndOasisOpendocumentText
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text'
	KMimeApplicationVndOasisOpendocumentText Mime = "application/vnd.oasis.opendocument.text"

	// KMimeApplicationVndOasisOpendocumentTextMaster
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text-master'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text-master'
	KMimeApplicationVndOasisOpendocumentTextMaster Mime = "application/vnd.oasis.opendocument.text-master"

	// KMimeApplicationVndOasisOpendocumentTextTemplate
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text-template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text-template'
	KMimeApplicationVndOasisOpendocumentTextTemplate Mime = "application/vnd.oasis.opendocument.text-template"

	// KMimeApplicationVndOasisOpendocumentTextWeb
	//
	// English:
	//
	//  Application type 'vnd.oasis.opendocument.text-web'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oasis.opendocument.text-web'
	KMimeApplicationVndOasisOpendocumentTextWeb Mime = "application/vnd.oasis.opendocument.text-web"

	// KMimeApplicationVndObn
	//
	// English:
	//
	//  Application type 'vnd.obn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.obn'
	KMimeApplicationVndObn Mime = "application/vnd.obn"

	// KMimeApplicationVndOcfCbor
	//
	// English:
	//
	//  Application type 'vnd.ocf+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ocf+cbor'
	KMimeApplicationVndOcfCbor Mime = "application/vnd.ocf+cbor"

	// KMimeApplicationVndOciImageManifestV1Json
	//
	// English:
	//
	//  Application type 'vnd.oci.image.manifest.v1+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oci.image.manifest.v1+json'
	KMimeApplicationVndOciImageManifestV1Json Mime = "application/vnd.oci.image.manifest.v1+json"

	// KMimeApplicationVndOftnL10nJson
	//
	// English:
	//
	//  Application type 'vnd.oftn.l10n+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oftn.l10n+json'
	KMimeApplicationVndOftnL10nJson Mime = "application/vnd.oftn.l10n+json"

	// KMimeApplicationVndOipfContentaccessdownloadXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.contentaccessdownload+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.contentaccessdownload+xml'
	KMimeApplicationVndOipfContentaccessdownloadXml Mime = "application/vnd.oipf.contentaccessdownload+xml"

	// KMimeApplicationVndOipfContentaccessstreamingXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.contentaccessstreaming+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.contentaccessstreaming+xml'
	KMimeApplicationVndOipfContentaccessstreamingXml Mime = "application/vnd.oipf.contentaccessstreaming+xml"

	// KMimeApplicationVndOipfCspgHexbinary
	//
	// English:
	//
	//  Application type 'vnd.oipf.cspg-hexbinary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.cspg-hexbinary'
	KMimeApplicationVndOipfCspgHexbinary Mime = "application/vnd.oipf.cspg-hexbinary"

	// KMimeApplicationVndOipfDaeSvgXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.dae.svg+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.dae.svg+xml'
	KMimeApplicationVndOipfDaeSvgXml Mime = "application/vnd.oipf.dae.svg+xml"

	// KMimeApplicationVndOipfDaeXhtmlXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.dae.xhtml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.dae.xhtml+xml'
	KMimeApplicationVndOipfDaeXhtmlXml Mime = "application/vnd.oipf.dae.xhtml+xml"

	// KMimeApplicationVndOipfMippvcontrolmessageXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.mippvcontrolmessage+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.mippvcontrolmessage+xml'
	KMimeApplicationVndOipfMippvcontrolmessageXml Mime = "application/vnd.oipf.mippvcontrolmessage+xml"

	// KMimeApplicationVndOipfPaeGem
	//
	// English:
	//
	//  Application type 'vnd.oipf.pae.gem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.pae.gem'
	KMimeApplicationVndOipfPaeGem Mime = "application/vnd.oipf.pae.gem"

	// KMimeApplicationVndOipfSpdiscoveryXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.spdiscovery+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.spdiscovery+xml'
	KMimeApplicationVndOipfSpdiscoveryXml Mime = "application/vnd.oipf.spdiscovery+xml"

	// KMimeApplicationVndOipfSpdlistXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.spdlist+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.spdlist+xml'
	KMimeApplicationVndOipfSpdlistXml Mime = "application/vnd.oipf.spdlist+xml"

	// KMimeApplicationVndOipfUeprofileXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.ueprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.ueprofile+xml'
	KMimeApplicationVndOipfUeprofileXml Mime = "application/vnd.oipf.ueprofile+xml"

	// KMimeApplicationVndOipfUserprofileXml
	//
	// English:
	//
	//  Application type 'vnd.oipf.userprofile+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oipf.userprofile+xml'
	KMimeApplicationVndOipfUserprofileXml Mime = "application/vnd.oipf.userprofile+xml"

	// KMimeApplicationVndOlpcSugar
	//
	// English:
	//
	//  Application type 'vnd.olpc-sugar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.olpc-sugar'
	KMimeApplicationVndOlpcSugar Mime = "application/vnd.olpc-sugar"

	// KMimeApplicationVndOmaBcastAssociatedProcedureParameterXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.associated-procedure-parameter+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.associated-procedure-parameter+xml'
	KMimeApplicationVndOmaBcastAssociatedProcedureParameterXml Mime = "application/vnd.oma.bcast.associated-procedure-parameter+xml"

	// KMimeApplicationVndOmaBcastDrmTriggerXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.drm-trigger+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.drm-trigger+xml'
	KMimeApplicationVndOmaBcastDrmTriggerXml Mime = "application/vnd.oma.bcast.drm-trigger+xml"

	// KMimeApplicationVndOmaBcastImdXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.imd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.imd+xml'
	KMimeApplicationVndOmaBcastImdXml Mime = "application/vnd.oma.bcast.imd+xml"

	// KMimeApplicationVndOmaBcastLtkm
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.ltkm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.ltkm'
	KMimeApplicationVndOmaBcastLtkm Mime = "application/vnd.oma.bcast.ltkm"

	// KMimeApplicationVndOmaBcastNotificationXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.notification+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.notification+xml'
	KMimeApplicationVndOmaBcastNotificationXml Mime = "application/vnd.oma.bcast.notification+xml"

	// KMimeApplicationVndOmaBcastProvisioningtrigger
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.provisioningtrigger'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.provisioningtrigger'
	KMimeApplicationVndOmaBcastProvisioningtrigger Mime = "application/vnd.oma.bcast.provisioningtrigger"

	// KMimeApplicationVndOmaBcastSgboot
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sgboot'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sgboot'
	KMimeApplicationVndOmaBcastSgboot Mime = "application/vnd.oma.bcast.sgboot"

	// KMimeApplicationVndOmaBcastSgddXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sgdd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sgdd+xml'
	KMimeApplicationVndOmaBcastSgddXml Mime = "application/vnd.oma.bcast.sgdd+xml"

	// KMimeApplicationVndOmaBcastSgdu
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sgdu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sgdu'
	KMimeApplicationVndOmaBcastSgdu Mime = "application/vnd.oma.bcast.sgdu"

	// KMimeApplicationVndOmaBcastSimpleSymbolContainer
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.simple-symbol-container'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.simple-symbol-container'
	KMimeApplicationVndOmaBcastSimpleSymbolContainer Mime = "application/vnd.oma.bcast.simple-symbol-container"

	// KMimeApplicationVndOmaBcastSmartcardTriggerXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.smartcard-trigger+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.smartcard-trigger+xml'
	KMimeApplicationVndOmaBcastSmartcardTriggerXml Mime = "application/vnd.oma.bcast.smartcard-trigger+xml"

	// KMimeApplicationVndOmaBcastSprovXml
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.sprov+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.sprov+xml'
	KMimeApplicationVndOmaBcastSprovXml Mime = "application/vnd.oma.bcast.sprov+xml"

	// KMimeApplicationVndOmaBcastStkm
	//
	// English:
	//
	//  Application type 'vnd.oma.bcast.stkm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.bcast.stkm'
	KMimeApplicationVndOmaBcastStkm Mime = "application/vnd.oma.bcast.stkm"

	// KMimeApplicationVndOmaCabAddressBookXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-address-book+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-address-book+xml'
	KMimeApplicationVndOmaCabAddressBookXml Mime = "application/vnd.oma.cab-address-book+xml"

	// KMimeApplicationVndOmaCabFeatureHandlerXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-feature-handler+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-feature-handler+xml'
	KMimeApplicationVndOmaCabFeatureHandlerXml Mime = "application/vnd.oma.cab-feature-handler+xml"

	// KMimeApplicationVndOmaCabPccXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-pcc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-pcc+xml'
	KMimeApplicationVndOmaCabPccXml Mime = "application/vnd.oma.cab-pcc+xml"

	// KMimeApplicationVndOmaCabSubsInviteXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-subs-invite+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-subs-invite+xml'
	KMimeApplicationVndOmaCabSubsInviteXml Mime = "application/vnd.oma.cab-subs-invite+xml"

	// KMimeApplicationVndOmaCabUserPrefsXml
	//
	// English:
	//
	//  Application type 'vnd.oma.cab-user-prefs+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.cab-user-prefs+xml'
	KMimeApplicationVndOmaCabUserPrefsXml Mime = "application/vnd.oma.cab-user-prefs+xml"

	// KMimeApplicationVndOmaDcd
	//
	// English:
	//
	//  Application type 'vnd.oma.dcd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.dcd'
	KMimeApplicationVndOmaDcd Mime = "application/vnd.oma.dcd"

	// KMimeApplicationVndOmaDcdc
	//
	// English:
	//
	//  Application type 'vnd.oma.dcdc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.dcdc'
	KMimeApplicationVndOmaDcdc Mime = "application/vnd.oma.dcdc"

	// KMimeApplicationVndOmaDd2Xml
	//
	// English:
	//
	//  Application type 'vnd.oma.dd2+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.dd2+xml'
	KMimeApplicationVndOmaDd2Xml Mime = "application/vnd.oma.dd2+xml"

	// KMimeApplicationVndOmaDrmRisdXml
	//
	// English:
	//
	//  Application type 'vnd.oma.drm.risd+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.drm.risd+xml'
	KMimeApplicationVndOmaDrmRisdXml Mime = "application/vnd.oma.drm.risd+xml"

	// KMimeApplicationVndOmaGroupUsageListXml
	//
	// English:
	//
	//  Application type 'vnd.oma.group-usage-list+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.group-usage-list+xml'
	KMimeApplicationVndOmaGroupUsageListXml Mime = "application/vnd.oma.group-usage-list+xml"

	// KMimeApplicationVndOmaLwm2mCbor
	//
	// English:
	//
	//  Application type 'vnd.oma.lwm2m+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.lwm2m+cbor'
	KMimeApplicationVndOmaLwm2mCbor Mime = "application/vnd.oma.lwm2m+cbor"

	// KMimeApplicationVndOmaLwm2mJson
	//
	// English:
	//
	//  Application type 'vnd.oma.lwm2m+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.lwm2m+json'
	KMimeApplicationVndOmaLwm2mJson Mime = "application/vnd.oma.lwm2m+json"

	// KMimeApplicationVndOmaLwm2mTlv
	//
	// English:
	//
	//  Application type 'vnd.oma.lwm2m+tlv'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.lwm2m+tlv'
	KMimeApplicationVndOmaLwm2mTlv Mime = "application/vnd.oma.lwm2m+tlv"

	// KMimeApplicationVndOmaPalXml
	//
	// English:
	//
	//  Application type 'vnd.oma.pal+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.pal+xml'
	KMimeApplicationVndOmaPalXml Mime = "application/vnd.oma.pal+xml"

	// KMimeApplicationVndOmaPocDetailedProgressReportXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.detailed-progress-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.detailed-progress-report+xml'
	KMimeApplicationVndOmaPocDetailedProgressReportXml Mime = "application/vnd.oma.poc.detailed-progress-report+xml"

	// KMimeApplicationVndOmaPocFinalReportXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.final-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.final-report+xml'
	KMimeApplicationVndOmaPocFinalReportXml Mime = "application/vnd.oma.poc.final-report+xml"

	// KMimeApplicationVndOmaPocGroupsXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.groups+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.groups+xml'
	KMimeApplicationVndOmaPocGroupsXml Mime = "application/vnd.oma.poc.groups+xml"

	// KMimeApplicationVndOmaPocInvocationDescriptorXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.invocation-descriptor+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.invocation-descriptor+xml'
	KMimeApplicationVndOmaPocInvocationDescriptorXml Mime = "application/vnd.oma.poc.invocation-descriptor+xml"

	// KMimeApplicationVndOmaPocOptimizedProgressReportXml
	//
	// English:
	//
	//  Application type 'vnd.oma.poc.optimized-progress-report+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.poc.optimized-progress-report+xml'
	KMimeApplicationVndOmaPocOptimizedProgressReportXml Mime = "application/vnd.oma.poc.optimized-progress-report+xml"

	// KMimeApplicationVndOmaPush
	//
	// English:
	//
	//  Application type 'vnd.oma.push'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.push'
	KMimeApplicationVndOmaPush Mime = "application/vnd.oma.push"

	// KMimeApplicationVndOmaScidmMessagesXml
	//
	// English:
	//
	//  Application type 'vnd.oma.scidm.messages+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.scidm.messages+xml'
	KMimeApplicationVndOmaScidmMessagesXml Mime = "application/vnd.oma.scidm.messages+xml"

	// KMimeApplicationVndOmaXcapDirectoryXml
	//
	// English:
	//
	//  Application type 'vnd.oma.xcap-directory+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma.xcap-directory+xml'
	KMimeApplicationVndOmaXcapDirectoryXml Mime = "application/vnd.oma.xcap-directory+xml"

	// KMimeApplicationVndOmadsEmailXml
	//
	// English:
	//
	//  Application type 'vnd.omads-email+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omads-email+xml'
	KMimeApplicationVndOmadsEmailXml Mime = "application/vnd.omads-email+xml"

	// KMimeApplicationVndOmadsFileXml
	//
	// English:
	//
	//  Application type 'vnd.omads-file+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omads-file+xml'
	KMimeApplicationVndOmadsFileXml Mime = "application/vnd.omads-file+xml"

	// KMimeApplicationVndOmadsFolderXml
	//
	// English:
	//
	//  Application type 'vnd.omads-folder+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omads-folder+xml'
	KMimeApplicationVndOmadsFolderXml Mime = "application/vnd.omads-folder+xml"

	// KMimeApplicationVndOmalocSuplInit
	//
	// English:
	//
	//  Application type 'vnd.omaloc-supl-init'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.omaloc-supl-init'
	KMimeApplicationVndOmalocSuplInit Mime = "application/vnd.omaloc-supl-init"

	// KMimeApplicationVndOmaScwsConfig
	//
	// English:
	//
	//  Application type 'vnd.oma-scws-config'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma-scws-config'
	KMimeApplicationVndOmaScwsConfig Mime = "application/vnd.oma-scws-config"

	// KMimeApplicationVndOmaScwsHttpRequest
	//
	// English:
	//
	//  Application type 'vnd.oma-scws-http-request'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma-scws-http-request'
	KMimeApplicationVndOmaScwsHttpRequest Mime = "application/vnd.oma-scws-http-request"

	// KMimeApplicationVndOmaScwsHttpResponse
	//
	// English:
	//
	//  Application type 'vnd.oma-scws-http-response'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oma-scws-http-response'
	KMimeApplicationVndOmaScwsHttpResponse Mime = "application/vnd.oma-scws-http-response"

	// KMimeApplicationVndOnepager
	//
	// English:
	//
	//  Application type 'vnd.onepager'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepager'
	KMimeApplicationVndOnepager Mime = "application/vnd.onepager"

	// KMimeApplicationVndOnepagertamp
	//
	// English:
	//
	//  Application type 'vnd.onepagertamp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertamp'
	KMimeApplicationVndOnepagertamp Mime = "application/vnd.onepagertamp"

	// KMimeApplicationVndOnepagertamx
	//
	// English:
	//
	//  Application type 'vnd.onepagertamx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertamx'
	KMimeApplicationVndOnepagertamx Mime = "application/vnd.onepagertamx"

	// KMimeApplicationVndOnepagertat
	//
	// English:
	//
	//  Application type 'vnd.onepagertat'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertat'
	KMimeApplicationVndOnepagertat Mime = "application/vnd.onepagertat"

	// KMimeApplicationVndOnepagertatp
	//
	// English:
	//
	//  Application type 'vnd.onepagertatp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertatp'
	KMimeApplicationVndOnepagertatp Mime = "application/vnd.onepagertatp"

	// KMimeApplicationVndOnepagertatx
	//
	// English:
	//
	//  Application type 'vnd.onepagertatx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onepagertatx'
	KMimeApplicationVndOnepagertatx Mime = "application/vnd.onepagertatx"

	// KMimeApplicationVndOnvifMetadata
	//
	// English:
	//
	//  Application type 'vnd.onvif.metadata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.onvif.metadata'
	KMimeApplicationVndOnvifMetadata Mime = "application/vnd.onvif.metadata"

	// KMimeApplicationVndOpenbloxGameBinary
	//
	// English:
	//
	//  Application type 'vnd.openblox.game-binary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openblox.game-binary'
	KMimeApplicationVndOpenbloxGameBinary Mime = "application/vnd.openblox.game-binary"

	// KMimeApplicationVndOpenbloxGameXml
	//
	// English:
	//
	//  Application type 'vnd.openblox.game+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openblox.game+xml'
	KMimeApplicationVndOpenbloxGameXml Mime = "application/vnd.openblox.game+xml"

	// KMimeApplicationVndOpeneyeOeb
	//
	// English:
	//
	//  Application type 'vnd.openeye.oeb'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openeye.oeb'
	KMimeApplicationVndOpeneyeOeb Mime = "application/vnd.openeye.oeb"

	// KMimeApplicationVndOpenstreetmapDataXml
	//
	// English:
	//
	//  Application type 'vnd.openstreetmap.data+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openstreetmap.data+xml'
	KMimeApplicationVndOpenstreetmapDataXml Mime = "application/vnd.openstreetmap.data+xml"

	// KMimeApplicationVndOpentimestampsOts
	//
	// English:
	//
	//  Application type 'vnd.opentimestamps.ots'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.opentimestamps.ots'
	KMimeApplicationVndOpentimestampsOts Mime = "application/vnd.opentimestamps.ots"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentCustomPropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.custom-properties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.custom-properties+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentCustomPropertiesXml Mime = "application/vnd.openxmlformats-officedocument.custom-properties+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentCustomXmlPropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.customXmlProperties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.customXmlProperties+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentCustomXmlPropertiesXml Mime = "application/vnd.openxmlformats-officedocument.customXmlProperties+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawing+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawing+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingXml Mime = "application/vnd.openxmlformats-officedocument.drawing+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.chart+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.chart+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartshapesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.chartshapes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.chartshapes+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlChartshapesXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramColorsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramColors+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramColors+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramColorsXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramDataXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramData+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramData+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramDataXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramLayoutXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramLayoutXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramStyleXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentDrawingmlDiagramStyleXml Mime = "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentExtendedPropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.extended-properties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.extended-properties+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentExtendedPropertiesXml Mime = "application/vnd.openxmlformats-officedocument.extended-properties+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentAuthorsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentAuthorsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.comments+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.comments+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlCommentsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.comments+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlHandoutMasterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlHandoutMasterXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.handoutMaster+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesMasterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.notesMaster+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.notesMaster+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesMasterXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.notesMaster+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesSlideXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.notesSlide+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.notesSlide+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlNotesSlideXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.notesSlide+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.presentation'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.presentation'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation Mime = "application/vnd.openxmlformats-officedocument.presentationml.presentation"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentationMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.presentation.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.presentation.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentationMainXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresPropsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.presProps+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.presProps+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresPropsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.presProps+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlide
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slide'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slide'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlide Mime = "application/vnd.openxmlformats-officedocument.presentationml.slide"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slide+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slide+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slide+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideLayoutXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideLayout+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideLayout+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideLayoutXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideLayout+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideMasterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideMaster+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideMaster+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideMasterXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideMaster+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshow
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideshow'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideshow'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshow Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideshow"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshowMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideshowMainXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideUpdateInfoXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlSlideUpdateInfoXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.slideUpdateInfo+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTableStylesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.tableStyles+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.tableStyles+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTableStylesXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.tableStyles+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTagsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.tags+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.tags+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTagsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.tags+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplate
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.template'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplate Mime = "application/vnd.openxmlformats-officedocument.presentationml.template"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplateMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.template.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.template.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlTemplateMainXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.template.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlViewPropsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.presentationml.viewProps+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.presentationml.viewProps+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentPresentationmlViewPropsXml Mime = "application/vnd.openxmlformats-officedocument.presentationml.viewProps+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCalcChainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCalcChainXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.calcChain+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlChartsheetXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlChartsheetXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCommentsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.comments+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.comments+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlCommentsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlConnectionsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.connections+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.connections+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlConnectionsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlDialogsheetXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlDialogsheetXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlExternalLinkXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlExternalLinkXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.externalLink+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheDefinitionXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheDefinitionXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheDefinition+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheRecordsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotCacheRecordsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotCacheRecords+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlPivotTableXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.pivotTable+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlQueryTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlQueryTableXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.queryTable+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionHeadersXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionHeadersXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionHeaders+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionLogXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlRevisionLogXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.revisionLog+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSharedStringsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSharedStringsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sheet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sheet'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMainXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMetadataXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheetMetadataXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheetMetadata+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlStylesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.styles+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlStylesXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.table+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableSingleCellsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTableSingleCellsXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.tableSingleCells+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplate
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.template'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplate Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.template"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplateMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlTemplateMainXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlUserNamesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlUserNamesXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.userNames+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlVolatileDependenciesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlVolatileDependenciesXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.volatileDependencies+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlWorksheetXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlWorksheetXml Mime = "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentThemeXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.theme+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.theme+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentThemeXml Mime = "application/vnd.openxmlformats-officedocument.theme+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentThemeOverrideXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.themeOverride+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.themeOverride+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentThemeOverrideXml Mime = "application/vnd.openxmlformats-officedocument.themeOverride+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentVmlDrawing
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.vmlDrawing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.vmlDrawing'
	KMimeApplicationVndOpenxmlformatsOfficedocumentVmlDrawing Mime = "application/vnd.openxmlformats-officedocument.vmlDrawing"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlCommentsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.comments+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.comments+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlCommentsXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.document'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.document'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentGlossaryXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentGlossaryXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocumentMainXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlEndnotesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlEndnotesXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFontTableXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFontTableXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFooterXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.footer+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.footer+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFooterXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFootnotesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlFootnotesXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlNumberingXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlNumberingXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlSettingsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.settings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.settings+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlSettingsXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlStylesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.styles+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.styles+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlStylesXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplate
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.template'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.template'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplate Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.template"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplateMainXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlTemplateMainXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml"

	// KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlWebSettingsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml'
	KMimeApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlWebSettingsXml Mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.webSettings+xml"

	// KMimeApplicationVndOpenxmlformatsPackageCorePropertiesXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-package.core-properties+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-package.core-properties+xml'
	KMimeApplicationVndOpenxmlformatsPackageCorePropertiesXml Mime = "application/vnd.openxmlformats-package.core-properties+xml"

	// KMimeApplicationVndOpenxmlformatsPackageDigitalSignatureXmlsignatureXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-package.digital-signature-xmlsignature+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-package.digital-signature-xmlsignature+xml'
	KMimeApplicationVndOpenxmlformatsPackageDigitalSignatureXmlsignatureXml Mime = "application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml"

	// KMimeApplicationVndOpenxmlformatsPackageRelationshipsXml
	//
	// English:
	//
	//  Application type 'vnd.openxmlformats-package.relationships+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.openxmlformats-package.relationships+xml'
	KMimeApplicationVndOpenxmlformatsPackageRelationshipsXml Mime = "application/vnd.openxmlformats-package.relationships+xml"

	// KMimeApplicationVndOracleResourceJson
	//
	// English:
	//
	//  Application type 'vnd.oracle.resource+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oracle.resource+json'
	KMimeApplicationVndOracleResourceJson Mime = "application/vnd.oracle.resource+json"

	// KMimeApplicationVndOrangeIndata
	//
	// English:
	//
	//  Application type 'vnd.orange.indata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.orange.indata'
	KMimeApplicationVndOrangeIndata Mime = "application/vnd.orange.indata"

	// KMimeApplicationVndOsaNetdeploy
	//
	// English:
	//
	//  Application type 'vnd.osa.netdeploy'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osa.netdeploy'
	KMimeApplicationVndOsaNetdeploy Mime = "application/vnd.osa.netdeploy"

	// KMimeApplicationVndOsgeoMapguidePackage
	//
	// English:
	//
	//  Application type 'vnd.osgeo.mapguide.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgeo.mapguide.package'
	KMimeApplicationVndOsgeoMapguidePackage Mime = "application/vnd.osgeo.mapguide.package"

	// KMimeApplicationVndOsgiBundle
	//
	// English:
	//
	//  Application type 'vnd.osgi.bundle'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgi.bundle'
	KMimeApplicationVndOsgiBundle Mime = "application/vnd.osgi.bundle"

	// KMimeApplicationVndOsgiDp
	//
	// English:
	//
	//  Application type 'vnd.osgi.dp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgi.dp'
	KMimeApplicationVndOsgiDp Mime = "application/vnd.osgi.dp"

	// KMimeApplicationVndOsgiSubsystem
	//
	// English:
	//
	//  Application type 'vnd.osgi.subsystem'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.osgi.subsystem'
	KMimeApplicationVndOsgiSubsystem Mime = "application/vnd.osgi.subsystem"

	// KMimeApplicationVndOtpsCtKipXml
	//
	// English:
	//
	//  Application type 'vnd.otps.ct-kip+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.otps.ct-kip+xml'
	KMimeApplicationVndOtpsCtKipXml Mime = "application/vnd.otps.ct-kip+xml"

	// KMimeApplicationVndOxliCountgraph
	//
	// English:
	//
	//  Application type 'vnd.oxli.countgraph'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.oxli.countgraph'
	KMimeApplicationVndOxliCountgraph Mime = "application/vnd.oxli.countgraph"

	// KMimeApplicationVndPagerdutyJson
	//
	// English:
	//
	//  Application type 'vnd.pagerduty+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pagerduty+json'
	KMimeApplicationVndPagerdutyJson Mime = "application/vnd.pagerduty+json"

	// KMimeApplicationVndPalm
	//
	// English:
	//
	//  Application type 'vnd.palm'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.palm'
	KMimeApplicationVndPalm Mime = "application/vnd.palm"

	// KMimeApplicationVndPanoply
	//
	// English:
	//
	//  Application type 'vnd.panoply'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.panoply'
	KMimeApplicationVndPanoply Mime = "application/vnd.panoply"

	// KMimeApplicationVndPaosXml
	//
	// English:
	//
	//  Application type 'vnd.paos.xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.paos.xml'
	KMimeApplicationVndPaosXml Mime = "application/vnd.paos.xml"

	// KMimeApplicationVndPatentdive
	//
	// English:
	//
	//  Application type 'vnd.patentdive'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.patentdive'
	KMimeApplicationVndPatentdive Mime = "application/vnd.patentdive"

	// KMimeApplicationVndPatientecommsdoc
	//
	// English:
	//
	//  Application type 'vnd.patientecommsdoc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.patientecommsdoc'
	KMimeApplicationVndPatientecommsdoc Mime = "application/vnd.patientecommsdoc"

	// KMimeApplicationVndPawaafile
	//
	// English:
	//
	//  Application type 'vnd.pawaafile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pawaafile'
	KMimeApplicationVndPawaafile Mime = "application/vnd.pawaafile"

	// KMimeApplicationVndPcos
	//
	// English:
	//
	//  Application type 'vnd.pcos'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pcos'
	KMimeApplicationVndPcos Mime = "application/vnd.pcos"

	// KMimeApplicationVndPgFormat
	//
	// English:
	//
	//  Application type 'vnd.pg.format'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pg.format'
	KMimeApplicationVndPgFormat Mime = "application/vnd.pg.format"

	// KMimeApplicationVndPgOsasli
	//
	// English:
	//
	//  Application type 'vnd.pg.osasli'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pg.osasli'
	KMimeApplicationVndPgOsasli Mime = "application/vnd.pg.osasli"

	// KMimeApplicationVndPiaccessApplicationLicence
	//
	// English:
	//
	//  Application type 'vnd.piaccess.application-licence'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.piaccess.application-licence'
	KMimeApplicationVndPiaccessApplicationLicence Mime = "application/vnd.piaccess.application-licence"

	// KMimeApplicationVndPicsel
	//
	// English:
	//
	//  Application type 'vnd.picsel'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.picsel'
	KMimeApplicationVndPicsel Mime = "application/vnd.picsel"

	// KMimeApplicationVndPmiWidget
	//
	// English:
	//
	//  Application type 'vnd.pmi.widget'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pmi.widget'
	KMimeApplicationVndPmiWidget Mime = "application/vnd.pmi.widget"

	// KMimeApplicationVndPocGroupAdvertisementXml
	//
	// English:
	//
	//  Application type 'vnd.poc.group-advertisement+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.poc.group-advertisement+xml'
	KMimeApplicationVndPocGroupAdvertisementXml Mime = "application/vnd.poc.group-advertisement+xml"

	// KMimeApplicationVndPocketlearn
	//
	// English:
	//
	//  Application type 'vnd.pocketlearn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pocketlearn'
	KMimeApplicationVndPocketlearn Mime = "application/vnd.pocketlearn"

	// KMimeApplicationVndPowerbuilder6
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder6'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder6'
	KMimeApplicationVndPowerbuilder6 Mime = "application/vnd.powerbuilder6"

	// KMimeApplicationVndPowerbuilder6S
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder6-s'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder6-s'
	KMimeApplicationVndPowerbuilder6S Mime = "application/vnd.powerbuilder6-s"

	// KMimeApplicationVndPowerbuilder7
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder7'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder7'
	KMimeApplicationVndPowerbuilder7 Mime = "application/vnd.powerbuilder7"

	// KMimeApplicationVndPowerbuilder75
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder75'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder75'
	KMimeApplicationVndPowerbuilder75 Mime = "application/vnd.powerbuilder75"

	// KMimeApplicationVndPowerbuilder75S
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder75-s'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder75-s'
	KMimeApplicationVndPowerbuilder75S Mime = "application/vnd.powerbuilder75-s"

	// KMimeApplicationVndPowerbuilder7S
	//
	// English:
	//
	//  Application type 'vnd.powerbuilder7-s'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.powerbuilder7-s'
	KMimeApplicationVndPowerbuilder7S Mime = "application/vnd.powerbuilder7-s"

	// KMimeApplicationVndPreminet
	//
	// English:
	//
	//  Application type 'vnd.preminet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.preminet'
	KMimeApplicationVndPreminet Mime = "application/vnd.preminet"

	// KMimeApplicationVndPreviewsystemsBox
	//
	// English:
	//
	//  Application type 'vnd.previewsystems.box'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.previewsystems.box'
	KMimeApplicationVndPreviewsystemsBox Mime = "application/vnd.previewsystems.box"

	// KMimeApplicationVndProteusMagazine
	//
	// English:
	//
	//  Application type 'vnd.proteus.magazine'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.proteus.magazine'
	KMimeApplicationVndProteusMagazine Mime = "application/vnd.proteus.magazine"

	// KMimeApplicationVndPsfs
	//
	// English:
	//
	//  Application type 'vnd.psfs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.psfs'
	KMimeApplicationVndPsfs Mime = "application/vnd.psfs"

	// KMimeApplicationVndPublishareDeltaTree
	//
	// English:
	//
	//  Application type 'vnd.publishare-delta-tree'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.publishare-delta-tree'
	KMimeApplicationVndPublishareDeltaTree Mime = "application/vnd.publishare-delta-tree"

	// KMimeApplicationVndPviPtid1
	//
	// English:
	//
	//  Application type 'vnd.pvi.ptid1'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pvi.ptid1'
	KMimeApplicationVndPviPtid1 Mime = "application/vnd.pvi.ptid1"

	// KMimeApplicationVndPwgMultiplexed
	//
	// English:
	//
	//  Application type 'vnd.pwg-multiplexed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pwg-multiplexed'
	KMimeApplicationVndPwgMultiplexed Mime = "application/vnd.pwg-multiplexed"

	// KMimeApplicationVndPwgXhtmlPrintXml
	//
	// English:
	//
	//  Application type 'vnd.pwg-xhtml-print+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.pwg-xhtml-print+xml'
	KMimeApplicationVndPwgXhtmlPrintXml Mime = "application/vnd.pwg-xhtml-print+xml"

	// KMimeApplicationVndQualcommBrewAppRes
	//
	// English:
	//
	//  Application type 'vnd.qualcomm.brew-app-res'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.qualcomm.brew-app-res'
	KMimeApplicationVndQualcommBrewAppRes Mime = "application/vnd.qualcomm.brew-app-res"

	// KMimeApplicationVndQuarantainenet
	//
	// English:
	//
	//  Application type 'vnd.quarantainenet'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.quarantainenet'
	KMimeApplicationVndQuarantainenet Mime = "application/vnd.quarantainenet"

	// KMimeApplicationVndQuarkQuarkXPress
	//
	// English:
	//
	//  Application type 'vnd.Quark.QuarkXPress'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.Quark.QuarkXPress'
	KMimeApplicationVndQuarkQuarkXPress Mime = "application/vnd.Quark.QuarkXPress"

	// KMimeApplicationVndQuobjectQuoxdocument
	//
	// English:
	//
	//  Application type 'vnd.quobject-quoxdocument'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.quobject-quoxdocument'
	KMimeApplicationVndQuobjectQuoxdocument Mime = "application/vnd.quobject-quoxdocument"

	// KMimeApplicationVndRadisysMomlXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.moml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.moml+xml'
	KMimeApplicationVndRadisysMomlXml Mime = "application/vnd.radisys.moml+xml"

	// KMimeApplicationVndRadisysMsmlAuditConfXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-conf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-conf+xml'
	KMimeApplicationVndRadisysMsmlAuditConfXml Mime = "application/vnd.radisys.msml-audit-conf+xml"

	// KMimeApplicationVndRadisysMsmlAuditConnXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-conn+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-conn+xml'
	KMimeApplicationVndRadisysMsmlAuditConnXml Mime = "application/vnd.radisys.msml-audit-conn+xml"

	// KMimeApplicationVndRadisysMsmlAuditDialogXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-dialog+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-dialog+xml'
	KMimeApplicationVndRadisysMsmlAuditDialogXml Mime = "application/vnd.radisys.msml-audit-dialog+xml"

	// KMimeApplicationVndRadisysMsmlAuditStreamXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit-stream+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit-stream+xml'
	KMimeApplicationVndRadisysMsmlAuditStreamXml Mime = "application/vnd.radisys.msml-audit-stream+xml"

	// KMimeApplicationVndRadisysMsmlAuditXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-audit+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-audit+xml'
	KMimeApplicationVndRadisysMsmlAuditXml Mime = "application/vnd.radisys.msml-audit+xml"

	// KMimeApplicationVndRadisysMsmlConfXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-conf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-conf+xml'
	KMimeApplicationVndRadisysMsmlConfXml Mime = "application/vnd.radisys.msml-conf+xml"

	// KMimeApplicationVndRadisysMsmlDialogBaseXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-base+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-base+xml'
	KMimeApplicationVndRadisysMsmlDialogBaseXml Mime = "application/vnd.radisys.msml-dialog-base+xml"

	// KMimeApplicationVndRadisysMsmlDialogFaxDetectXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-fax-detect+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-fax-detect+xml'
	KMimeApplicationVndRadisysMsmlDialogFaxDetectXml Mime = "application/vnd.radisys.msml-dialog-fax-detect+xml"

	// KMimeApplicationVndRadisysMsmlDialogFaxSendrecvXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-fax-sendrecv+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-fax-sendrecv+xml'
	KMimeApplicationVndRadisysMsmlDialogFaxSendrecvXml Mime = "application/vnd.radisys.msml-dialog-fax-sendrecv+xml"

	// KMimeApplicationVndRadisysMsmlDialogGroupXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-group+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-group+xml'
	KMimeApplicationVndRadisysMsmlDialogGroupXml Mime = "application/vnd.radisys.msml-dialog-group+xml"

	// KMimeApplicationVndRadisysMsmlDialogSpeechXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-speech+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-speech+xml'
	KMimeApplicationVndRadisysMsmlDialogSpeechXml Mime = "application/vnd.radisys.msml-dialog-speech+xml"

	// KMimeApplicationVndRadisysMsmlDialogTransformXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog-transform+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog-transform+xml'
	KMimeApplicationVndRadisysMsmlDialogTransformXml Mime = "application/vnd.radisys.msml-dialog-transform+xml"

	// KMimeApplicationVndRadisysMsmlDialogXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml-dialog+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml-dialog+xml'
	KMimeApplicationVndRadisysMsmlDialogXml Mime = "application/vnd.radisys.msml-dialog+xml"

	// KMimeApplicationVndRadisysMsmlXml
	//
	// English:
	//
	//  Application type 'vnd.radisys.msml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.radisys.msml+xml'
	KMimeApplicationVndRadisysMsmlXml Mime = "application/vnd.radisys.msml+xml"

	// KMimeApplicationVndRainstorData
	//
	// English:
	//
	//  Application type 'vnd.rainstor.data'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rainstor.data'
	KMimeApplicationVndRainstorData Mime = "application/vnd.rainstor.data"

	// KMimeApplicationVndRapid
	//
	// English:
	//
	//  Application type 'vnd.rapid'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rapid'
	KMimeApplicationVndRapid Mime = "application/vnd.rapid"

	// KMimeApplicationVndRar
	//
	// English:
	//
	//  Application type 'vnd.rar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rar'
	KMimeApplicationVndRar Mime = "application/vnd.rar"

	// KMimeApplicationVndRealvncBed
	//
	// English:
	//
	//  Application type 'vnd.realvnc.bed'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.realvnc.bed'
	KMimeApplicationVndRealvncBed Mime = "application/vnd.realvnc.bed"

	// KMimeApplicationVndRecordareMusicxml
	//
	// English:
	//
	//  Application type 'vnd.recordare.musicxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.recordare.musicxml'
	KMimeApplicationVndRecordareMusicxml Mime = "application/vnd.recordare.musicxml"

	// KMimeApplicationVndRecordareMusicxmlXml
	//
	// English:
	//
	//  Application type 'vnd.recordare.musicxml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.recordare.musicxml+xml'
	KMimeApplicationVndRecordareMusicxmlXml Mime = "application/vnd.recordare.musicxml+xml"

	// KMimeApplicationVndRenLearnRlprint
	//
	// English:
	//
	//  Application type 'vnd.RenLearn.rlprint'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.RenLearn.rlprint'
	KMimeApplicationVndRenLearnRlprint Mime = "application/vnd.RenLearn.rlprint"

	// KMimeApplicationVndResilientLogic
	//
	// English:
	//
	//  Application type 'vnd.resilient.logic'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.resilient.logic'
	KMimeApplicationVndResilientLogic Mime = "application/vnd.resilient.logic"

	// KMimeApplicationVndRestfulJson
	//
	// English:
	//
	//  Application type 'vnd.restful+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.restful+json'
	KMimeApplicationVndRestfulJson Mime = "application/vnd.restful+json"

	// KMimeApplicationVndRigCryptonote
	//
	// English:
	//
	//  Application type 'vnd.rig.cryptonote'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rig.cryptonote'
	KMimeApplicationVndRigCryptonote Mime = "application/vnd.rig.cryptonote"

	// KMimeApplicationVndRoute66Link66Xml
	//
	// English:
	//
	//  Application type 'vnd.route66.link66+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.route66.link66+xml'
	KMimeApplicationVndRoute66Link66Xml Mime = "application/vnd.route66.link66+xml"

	// KMimeApplicationVndRs274x
	//
	// English:
	//
	//  Application type 'vnd.rs-274x'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.rs-274x'
	KMimeApplicationVndRs274x Mime = "application/vnd.rs-274x"

	// KMimeApplicationVndRuckusDownload
	//
	// English:
	//
	//  Application type 'vnd.ruckus.download'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ruckus.download'
	KMimeApplicationVndRuckusDownload Mime = "application/vnd.ruckus.download"

	// KMimeApplicationVndS3sms
	//
	// English:
	//
	//  Application type 'vnd.s3sms'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.s3sms'
	KMimeApplicationVndS3sms Mime = "application/vnd.s3sms"

	// KMimeApplicationVndSailingtrackerTrack
	//
	// English:
	//
	//  Application type 'vnd.sailingtracker.track'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sailingtracker.track'
	KMimeApplicationVndSailingtrackerTrack Mime = "application/vnd.sailingtracker.track"

	// KMimeApplicationVndSar
	//
	// English:
	//
	//  Application type 'vnd.sar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sar'
	KMimeApplicationVndSar Mime = "application/vnd.sar"

	// KMimeApplicationVndSbmCid
	//
	// English:
	//
	//  Application type 'vnd.sbm.cid'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sbm.cid'
	KMimeApplicationVndSbmCid Mime = "application/vnd.sbm.cid"

	// KMimeApplicationVndSbmMid2
	//
	// English:
	//
	//  Application type 'vnd.sbm.mid2'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sbm.mid2'
	KMimeApplicationVndSbmMid2 Mime = "application/vnd.sbm.mid2"

	// KMimeApplicationVndScribus
	//
	// English:
	//
	//  Application type 'vnd.scribus'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.scribus'
	KMimeApplicationVndScribus Mime = "application/vnd.scribus"

	// KMimeApplicationVndSealed3df
	//
	// English:
	//
	//  Application type 'vnd.sealed.3df'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.3df'
	KMimeApplicationVndSealed3df Mime = "application/vnd.sealed.3df"

	// KMimeApplicationVndSealedCsf
	//
	// English:
	//
	//  Application type 'vnd.sealed.csf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.csf'
	KMimeApplicationVndSealedCsf Mime = "application/vnd.sealed.csf"

	// KMimeApplicationVndSealedDoc
	//
	// English:
	//
	//  Application type 'vnd.sealed.doc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.doc'
	KMimeApplicationVndSealedDoc Mime = "application/vnd.sealed.doc"

	// KMimeApplicationVndSealedEml
	//
	// English:
	//
	//  Application type 'vnd.sealed.eml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.eml'
	KMimeApplicationVndSealedEml Mime = "application/vnd.sealed.eml"

	// KMimeApplicationVndSealedMht
	//
	// English:
	//
	//  Application type 'vnd.sealed.mht'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.mht'
	KMimeApplicationVndSealedMht Mime = "application/vnd.sealed.mht"

	// KMimeApplicationVndSealedNet
	//
	// English:
	//
	//  Application type 'vnd.sealed.net'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.net'
	KMimeApplicationVndSealedNet Mime = "application/vnd.sealed.net"

	// KMimeApplicationVndSealedPpt
	//
	// English:
	//
	//  Application type 'vnd.sealed.ppt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.ppt'
	KMimeApplicationVndSealedPpt Mime = "application/vnd.sealed.ppt"

	// KMimeApplicationVndSealedTiff
	//
	// English:
	//
	//  Application type 'vnd.sealed.tiff'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.tiff'
	KMimeApplicationVndSealedTiff Mime = "application/vnd.sealed.tiff"

	// KMimeApplicationVndSealedXls
	//
	// English:
	//
	//  Application type 'vnd.sealed.xls'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealed.xls'
	KMimeApplicationVndSealedXls Mime = "application/vnd.sealed.xls"

	// KMimeApplicationVndSealedmediaSoftsealHtml
	//
	// English:
	//
	//  Application type 'vnd.sealedmedia.softseal.html'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealedmedia.softseal.html'
	KMimeApplicationVndSealedmediaSoftsealHtml Mime = "application/vnd.sealedmedia.softseal.html"

	// KMimeApplicationVndSealedmediaSoftsealPdf
	//
	// English:
	//
	//  Application type 'vnd.sealedmedia.softseal.pdf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sealedmedia.softseal.pdf'
	KMimeApplicationVndSealedmediaSoftsealPdf Mime = "application/vnd.sealedmedia.softseal.pdf"

	// KMimeApplicationVndSeemail
	//
	// English:
	//
	//  Application type 'vnd.seemail'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.seemail'
	KMimeApplicationVndSeemail Mime = "application/vnd.seemail"

	// KMimeApplicationVndSeisJson
	//
	// English:
	//
	//  Application type 'vnd.seis+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.seis+json'
	KMimeApplicationVndSeisJson Mime = "application/vnd.seis+json"

	// KMimeApplicationVndSema
	//
	// English:
	//
	//  Application type 'vnd.sema'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sema'
	KMimeApplicationVndSema Mime = "application/vnd.sema"

	// KMimeApplicationVndSemd
	//
	// English:
	//
	//  Application type 'vnd.semd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.semd'
	KMimeApplicationVndSemd Mime = "application/vnd.semd"

	// KMimeApplicationVndSemf
	//
	// English:
	//
	//  Application type 'vnd.semf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.semf'
	KMimeApplicationVndSemf Mime = "application/vnd.semf"

	// KMimeApplicationVndShadeSaveFile
	//
	// English:
	//
	//  Application type 'vnd.shade-save-file'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shade-save-file'
	KMimeApplicationVndShadeSaveFile Mime = "application/vnd.shade-save-file"

	// KMimeApplicationVndShanaInformedFormdata
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.formdata'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.formdata'
	KMimeApplicationVndShanaInformedFormdata Mime = "application/vnd.shana.informed.formdata"

	// KMimeApplicationVndShanaInformedFormtemplate
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.formtemplate'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.formtemplate'
	KMimeApplicationVndShanaInformedFormtemplate Mime = "application/vnd.shana.informed.formtemplate"

	// KMimeApplicationVndShanaInformedInterchange
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.interchange'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.interchange'
	KMimeApplicationVndShanaInformedInterchange Mime = "application/vnd.shana.informed.interchange"

	// KMimeApplicationVndShanaInformedPackage
	//
	// English:
	//
	//  Application type 'vnd.shana.informed.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shana.informed.package'
	KMimeApplicationVndShanaInformedPackage Mime = "application/vnd.shana.informed.package"

	// KMimeApplicationVndShootproofJson
	//
	// English:
	//
	//  Application type 'vnd.shootproof+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shootproof+json'
	KMimeApplicationVndShootproofJson Mime = "application/vnd.shootproof+json"

	// KMimeApplicationVndShopkickJson
	//
	// English:
	//
	//  Application type 'vnd.shopkick+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shopkick+json'
	KMimeApplicationVndShopkickJson Mime = "application/vnd.shopkick+json"

	// KMimeApplicationVndShp
	//
	// English:
	//
	//  Application type 'vnd.shp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shp'
	KMimeApplicationVndShp Mime = "application/vnd.shp"

	// KMimeApplicationVndShx
	//
	// English:
	//
	//  Application type 'vnd.shx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.shx'
	KMimeApplicationVndShx Mime = "application/vnd.shx"

	// KMimeApplicationVndSigrokSession
	//
	// English:
	//
	//  Application type 'vnd.sigrok.session'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sigrok.session'
	KMimeApplicationVndSigrokSession Mime = "application/vnd.sigrok.session"

	// KMimeApplicationVndSimTechMindMapper
	//
	// English:
	//
	//  Application type 'vnd.SimTech-MindMapper'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.SimTech-MindMapper'
	KMimeApplicationVndSimTechMindMapper Mime = "application/vnd.SimTech-MindMapper"

	// KMimeApplicationVndSirenJson
	//
	// English:
	//
	//  Application type 'vnd.siren+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.siren+json'
	KMimeApplicationVndSirenJson Mime = "application/vnd.siren+json"

	// KMimeApplicationVndSmaf
	//
	// English:
	//
	//  Application type 'vnd.smaf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.smaf'
	KMimeApplicationVndSmaf Mime = "application/vnd.smaf"

	// KMimeApplicationVndSmartNotebook
	//
	// English:
	//
	//  Application type 'vnd.smart.notebook'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.smart.notebook'
	KMimeApplicationVndSmartNotebook Mime = "application/vnd.smart.notebook"

	// KMimeApplicationVndSmartTeacher
	//
	// English:
	//
	//  Application type 'vnd.smart.teacher'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.smart.teacher'
	KMimeApplicationVndSmartTeacher Mime = "application/vnd.smart.teacher"

	// KMimeApplicationVndSnesdevPageTable
	//
	// English:
	//
	//  Application type 'vnd.snesdev-page-table'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.snesdev-page-table'
	KMimeApplicationVndSnesdevPageTable Mime = "application/vnd.snesdev-page-table"

	// KMimeApplicationVndSoftware602FillerFormXml
	//
	// English:
	//
	//  Application type 'vnd.software602.filler.form+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.software602.filler.form+xml'
	KMimeApplicationVndSoftware602FillerFormXml Mime = "application/vnd.software602.filler.form+xml"

	// KMimeApplicationVndSoftware602FillerFormXmlZip
	//
	// English:
	//
	//  Application type 'vnd.software602.filler.form-xml-zip'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.software602.filler.form-xml-zip'
	KMimeApplicationVndSoftware602FillerFormXmlZip Mime = "application/vnd.software602.filler.form-xml-zip"

	// KMimeApplicationVndSolentSdkmXml
	//
	// English:
	//
	//  Application type 'vnd.solent.sdkm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.solent.sdkm+xml'
	KMimeApplicationVndSolentSdkmXml Mime = "application/vnd.solent.sdkm+xml"

	// KMimeApplicationVndSpotfireDxp
	//
	// English:
	//
	//  Application type 'vnd.spotfire.dxp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.spotfire.dxp'
	KMimeApplicationVndSpotfireDxp Mime = "application/vnd.spotfire.dxp"

	// KMimeApplicationVndSpotfireSfs
	//
	// English:
	//
	//  Application type 'vnd.spotfire.sfs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.spotfire.sfs'
	KMimeApplicationVndSpotfireSfs Mime = "application/vnd.spotfire.sfs"

	// KMimeApplicationVndSqlite3
	//
	// English:
	//
	//  Application type 'vnd.sqlite3'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sqlite3'
	KMimeApplicationVndSqlite3 Mime = "application/vnd.sqlite3"

	// KMimeApplicationVndSssCod
	//
	// English:
	//
	//  Application type 'vnd.sss-cod'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sss-cod'
	KMimeApplicationVndSssCod Mime = "application/vnd.sss-cod"

	// KMimeApplicationVndSssDtf
	//
	// English:
	//
	//  Application type 'vnd.sss-dtf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sss-dtf'
	KMimeApplicationVndSssDtf Mime = "application/vnd.sss-dtf"

	// KMimeApplicationVndSssNtf
	//
	// English:
	//
	//  Application type 'vnd.sss-ntf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sss-ntf'
	KMimeApplicationVndSssNtf Mime = "application/vnd.sss-ntf"

	// KMimeApplicationVndStepmaniaPackage
	//
	// English:
	//
	//  Application type 'vnd.stepmania.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.stepmania.package'
	KMimeApplicationVndStepmaniaPackage Mime = "application/vnd.stepmania.package"

	// KMimeApplicationVndStepmaniaStepchart
	//
	// English:
	//
	//  Application type 'vnd.stepmania.stepchart'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.stepmania.stepchart'
	KMimeApplicationVndStepmaniaStepchart Mime = "application/vnd.stepmania.stepchart"

	// KMimeApplicationVndStreetStream
	//
	// English:
	//
	//  Application type 'vnd.street-stream'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.street-stream'
	KMimeApplicationVndStreetStream Mime = "application/vnd.street-stream"

	// KMimeApplicationVndSunWadlXml
	//
	// English:
	//
	//  Application type 'vnd.sun.wadl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sun.wadl+xml'
	KMimeApplicationVndSunWadlXml Mime = "application/vnd.sun.wadl+xml"

	// KMimeApplicationVndSusCalendar
	//
	// English:
	//
	//  Application type 'vnd.sus-calendar'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sus-calendar'
	KMimeApplicationVndSusCalendar Mime = "application/vnd.sus-calendar"

	// KMimeApplicationVndSvd
	//
	// English:
	//
	//  Application type 'vnd.svd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.svd'
	KMimeApplicationVndSvd Mime = "application/vnd.svd"

	// KMimeApplicationVndSwiftviewIcs
	//
	// English:
	//
	//  Application type 'vnd.swiftview-ics'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.swiftview-ics'
	KMimeApplicationVndSwiftviewIcs Mime = "application/vnd.swiftview-ics"

	// KMimeApplicationVndSycleXml
	//
	// English:
	//
	//  Application type 'vnd.sycle+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.sycle+xml'
	KMimeApplicationVndSycleXml Mime = "application/vnd.sycle+xml"

	// KMimeApplicationVndSyftJson
	//
	// English:
	//
	//  Application type 'vnd.syft+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syft+json'
	KMimeApplicationVndSyftJson Mime = "application/vnd.syft+json"

	// KMimeApplicationVndSyncmlDmNotification
	//
	// English:
	//
	//  Application type 'vnd.syncml.dm.notification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dm.notification'
	KMimeApplicationVndSyncmlDmNotification Mime = "application/vnd.syncml.dm.notification"

	// KMimeApplicationVndSyncmlDmddfXml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmddf+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmddf+xml'
	KMimeApplicationVndSyncmlDmddfXml Mime = "application/vnd.syncml.dmddf+xml"

	// KMimeApplicationVndSyncmlDmtndsWbxml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmtnds+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmtnds+wbxml'
	KMimeApplicationVndSyncmlDmtndsWbxml Mime = "application/vnd.syncml.dmtnds+wbxml"

	// KMimeApplicationVndSyncmlDmtndsXml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmtnds+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmtnds+xml'
	KMimeApplicationVndSyncmlDmtndsXml Mime = "application/vnd.syncml.dmtnds+xml"

	// KMimeApplicationVndSyncmlDmddfWbxml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dmddf+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dmddf+wbxml'
	KMimeApplicationVndSyncmlDmddfWbxml Mime = "application/vnd.syncml.dmddf+wbxml"

	// KMimeApplicationVndSyncmlDmWbxml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dm+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dm+wbxml'
	KMimeApplicationVndSyncmlDmWbxml Mime = "application/vnd.syncml.dm+wbxml"

	// KMimeApplicationVndSyncmlDmXml
	//
	// English:
	//
	//  Application type 'vnd.syncml.dm+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.dm+xml'
	KMimeApplicationVndSyncmlDmXml Mime = "application/vnd.syncml.dm+xml"

	// KMimeApplicationVndSyncmlDsNotification
	//
	// English:
	//
	//  Application type 'vnd.syncml.ds.notification'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml.ds.notification'
	KMimeApplicationVndSyncmlDsNotification Mime = "application/vnd.syncml.ds.notification"

	// KMimeApplicationVndSyncmlXml
	//
	// English:
	//
	//  Application type 'vnd.syncml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.syncml+xml'
	KMimeApplicationVndSyncmlXml Mime = "application/vnd.syncml+xml"

	// KMimeApplicationVndTableschemaJson
	//
	// English:
	//
	//  Application type 'vnd.tableschema+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tableschema+json'
	KMimeApplicationVndTableschemaJson Mime = "application/vnd.tableschema+json"

	// KMimeApplicationVndTaoIntentModuleArchive
	//
	// English:
	//
	//  Application type 'vnd.tao.intent-module-archive'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tao.intent-module-archive'
	KMimeApplicationVndTaoIntentModuleArchive Mime = "application/vnd.tao.intent-module-archive"

	// KMimeApplicationVndTcpdumpPcap
	//
	// English:
	//
	//  Application type 'vnd.tcpdump.pcap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tcpdump.pcap'
	KMimeApplicationVndTcpdumpPcap Mime = "application/vnd.tcpdump.pcap"

	// KMimeApplicationVndThinkCellPpttcJson
	//
	// English:
	//
	//  Application type 'vnd.think-cell.ppttc+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.think-cell.ppttc+json'
	KMimeApplicationVndThinkCellPpttcJson Mime = "application/vnd.think-cell.ppttc+json"

	// KMimeApplicationVndTml
	//
	// English:
	//
	//  Application type 'vnd.tml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tml'
	KMimeApplicationVndTml Mime = "application/vnd.tml"

	// KMimeApplicationVndTmdMediaflexApiXml
	//
	// English:
	//
	//  Application type 'vnd.tmd.mediaflex.api+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tmd.mediaflex.api+xml'
	KMimeApplicationVndTmdMediaflexApiXml Mime = "application/vnd.tmd.mediaflex.api+xml"

	// KMimeApplicationVndTmobileLivetv
	//
	// English:
	//
	//  Application type 'vnd.tmobile-livetv'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tmobile-livetv'
	KMimeApplicationVndTmobileLivetv Mime = "application/vnd.tmobile-livetv"

	// KMimeApplicationVndTriOnesource
	//
	// English:
	//
	//  Application type 'vnd.tri.onesource'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.tri.onesource'
	KMimeApplicationVndTriOnesource Mime = "application/vnd.tri.onesource"

	// KMimeApplicationVndTridTpt
	//
	// English:
	//
	//  Application type 'vnd.trid.tpt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.trid.tpt'
	KMimeApplicationVndTridTpt Mime = "application/vnd.trid.tpt"

	// KMimeApplicationVndTriscapeMxs
	//
	// English:
	//
	//  Application type 'vnd.triscape.mxs'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.triscape.mxs'
	KMimeApplicationVndTriscapeMxs Mime = "application/vnd.triscape.mxs"

	// KMimeApplicationVndTrueapp
	//
	// English:
	//
	//  Application type 'vnd.trueapp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.trueapp'
	KMimeApplicationVndTrueapp Mime = "application/vnd.trueapp"

	// KMimeApplicationVndTruedoc
	//
	// English:
	//
	//  Application type 'vnd.truedoc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.truedoc'
	KMimeApplicationVndTruedoc Mime = "application/vnd.truedoc"

	// KMimeApplicationVndUbisoftWebplayer
	//
	// English:
	//
	//  Application type 'vnd.ubisoft.webplayer'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ubisoft.webplayer'
	KMimeApplicationVndUbisoftWebplayer Mime = "application/vnd.ubisoft.webplayer"

	// KMimeApplicationVndUfdl
	//
	// English:
	//
	//  Application type 'vnd.ufdl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ufdl'
	KMimeApplicationVndUfdl Mime = "application/vnd.ufdl"

	// KMimeApplicationVndUiqTheme
	//
	// English:
	//
	//  Application type 'vnd.uiq.theme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uiq.theme'
	KMimeApplicationVndUiqTheme Mime = "application/vnd.uiq.theme"

	// KMimeApplicationVndUmajin
	//
	// English:
	//
	//  Application type 'vnd.umajin'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.umajin'
	KMimeApplicationVndUmajin Mime = "application/vnd.umajin"

	// KMimeApplicationVndUnity
	//
	// English:
	//
	//  Application type 'vnd.unity'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.unity'
	KMimeApplicationVndUnity Mime = "application/vnd.unity"

	// KMimeApplicationVndUomlXml
	//
	// English:
	//
	//  Application type 'vnd.uoml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uoml+xml'
	KMimeApplicationVndUomlXml Mime = "application/vnd.uoml+xml"

	// KMimeApplicationVndUplanetAlert
	//
	// English:
	//
	//  Application type 'vnd.uplanet.alert'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.alert'
	KMimeApplicationVndUplanetAlert Mime = "application/vnd.uplanet.alert"

	// KMimeApplicationVndUplanetAlertWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.alert-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.alert-wbxml'
	KMimeApplicationVndUplanetAlertWbxml Mime = "application/vnd.uplanet.alert-wbxml"

	// KMimeApplicationVndUplanetBearerChoice
	//
	// English:
	//
	//  Application type 'vnd.uplanet.bearer-choice'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.bearer-choice'
	KMimeApplicationVndUplanetBearerChoice Mime = "application/vnd.uplanet.bearer-choice"

	// KMimeApplicationVndUplanetBearerChoiceWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.bearer-choice-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.bearer-choice-wbxml'
	KMimeApplicationVndUplanetBearerChoiceWbxml Mime = "application/vnd.uplanet.bearer-choice-wbxml"

	// KMimeApplicationVndUplanetCacheop
	//
	// English:
	//
	//  Application type 'vnd.uplanet.cacheop'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.cacheop'
	KMimeApplicationVndUplanetCacheop Mime = "application/vnd.uplanet.cacheop"

	// KMimeApplicationVndUplanetCacheopWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.cacheop-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.cacheop-wbxml'
	KMimeApplicationVndUplanetCacheopWbxml Mime = "application/vnd.uplanet.cacheop-wbxml"

	// KMimeApplicationVndUplanetChannel
	//
	// English:
	//
	//  Application type 'vnd.uplanet.channel'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.channel'
	KMimeApplicationVndUplanetChannel Mime = "application/vnd.uplanet.channel"

	// KMimeApplicationVndUplanetChannelWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.channel-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.channel-wbxml'
	KMimeApplicationVndUplanetChannelWbxml Mime = "application/vnd.uplanet.channel-wbxml"

	// KMimeApplicationVndUplanetList
	//
	// English:
	//
	//  Application type 'vnd.uplanet.list'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.list'
	KMimeApplicationVndUplanetList Mime = "application/vnd.uplanet.list"

	// KMimeApplicationVndUplanetListcmd
	//
	// English:
	//
	//  Application type 'vnd.uplanet.listcmd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.listcmd'
	KMimeApplicationVndUplanetListcmd Mime = "application/vnd.uplanet.listcmd"

	// KMimeApplicationVndUplanetListcmdWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.listcmd-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.listcmd-wbxml'
	KMimeApplicationVndUplanetListcmdWbxml Mime = "application/vnd.uplanet.listcmd-wbxml"

	// KMimeApplicationVndUplanetListWbxml
	//
	// English:
	//
	//  Application type 'vnd.uplanet.list-wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.list-wbxml'
	KMimeApplicationVndUplanetListWbxml Mime = "application/vnd.uplanet.list-wbxml"

	// KMimeApplicationVndUriMap
	//
	// English:
	//
	//  Application type 'vnd.uri-map'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uri-map'
	KMimeApplicationVndUriMap Mime = "application/vnd.uri-map"

	// KMimeApplicationVndUplanetSignal
	//
	// English:
	//
	//  Application type 'vnd.uplanet.signal'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.uplanet.signal'
	KMimeApplicationVndUplanetSignal Mime = "application/vnd.uplanet.signal"

	// KMimeApplicationVndValveSourceMaterial
	//
	// English:
	//
	//  Application type 'vnd.valve.source.material'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.valve.source.material'
	KMimeApplicationVndValveSourceMaterial Mime = "application/vnd.valve.source.material"

	// KMimeApplicationVndVcx
	//
	// English:
	//
	//  Application type 'vnd.vcx'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vcx'
	KMimeApplicationVndVcx Mime = "application/vnd.vcx"

	// KMimeApplicationVndVdStudy
	//
	// English:
	//
	//  Application type 'vnd.vd-study'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vd-study'
	KMimeApplicationVndVdStudy Mime = "application/vnd.vd-study"

	// KMimeApplicationVndVectorworks
	//
	// English:
	//
	//  Application type 'vnd.vectorworks'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vectorworks'
	KMimeApplicationVndVectorworks Mime = "application/vnd.vectorworks"

	// KMimeApplicationVndVelJson
	//
	// English:
	//
	//  Application type 'vnd.vel+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vel+json'
	KMimeApplicationVndVelJson Mime = "application/vnd.vel+json"

	// KMimeApplicationVndVerimatrixVcas
	//
	// English:
	//
	//  Application type 'vnd.verimatrix.vcas'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.verimatrix.vcas'
	KMimeApplicationVndVerimatrixVcas Mime = "application/vnd.verimatrix.vcas"

	// KMimeApplicationVndVeritoneAionJson
	//
	// English:
	//
	//  Application type 'vnd.veritone.aion+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.veritone.aion+json'
	KMimeApplicationVndVeritoneAionJson Mime = "application/vnd.veritone.aion+json"

	// KMimeApplicationVndVeryantThin
	//
	// English:
	//
	//  Application type 'vnd.veryant.thin'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.veryant.thin'
	KMimeApplicationVndVeryantThin Mime = "application/vnd.veryant.thin"

	// KMimeApplicationVndVesEncrypted
	//
	// English:
	//
	//  Application type 'vnd.ves.encrypted'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.ves.encrypted'
	KMimeApplicationVndVesEncrypted Mime = "application/vnd.ves.encrypted"

	// KMimeApplicationVndVidsoftVidconference
	//
	// English:
	//
	//  Application type 'vnd.vidsoft.vidconference'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vidsoft.vidconference'
	KMimeApplicationVndVidsoftVidconference Mime = "application/vnd.vidsoft.vidconference"

	// KMimeApplicationVndVisio
	//
	// English:
	//
	//  Application type 'vnd.visio'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.visio'
	KMimeApplicationVndVisio Mime = "application/vnd.visio"

	// KMimeApplicationVndVisionary
	//
	// English:
	//
	//  Application type 'vnd.visionary'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.visionary'
	KMimeApplicationVndVisionary Mime = "application/vnd.visionary"

	// KMimeApplicationVndVividenceScriptfile
	//
	// English:
	//
	//  Application type 'vnd.vividence.scriptfile'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vividence.scriptfile'
	KMimeApplicationVndVividenceScriptfile Mime = "application/vnd.vividence.scriptfile"

	// KMimeApplicationVndVsf
	//
	// English:
	//
	//  Application type 'vnd.vsf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.vsf'
	KMimeApplicationVndVsf Mime = "application/vnd.vsf"

	// KMimeApplicationVndWapSic
	//
	// English:
	//
	//  Application type 'vnd.wap.sic'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.sic'
	KMimeApplicationVndWapSic Mime = "application/vnd.wap.sic"

	// KMimeApplicationVndWapSlc
	//
	// English:
	//
	//  Application type 'vnd.wap.slc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.slc'
	KMimeApplicationVndWapSlc Mime = "application/vnd.wap.slc"

	// KMimeApplicationVndWapWbxml
	//
	// English:
	//
	//  Application type 'vnd.wap.wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.wbxml'
	KMimeApplicationVndWapWbxml Mime = "application/vnd.wap.wbxml"

	// KMimeApplicationVndWapWmlc
	//
	// English:
	//
	//  Application type 'vnd.wap.wmlc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.wmlc'
	KMimeApplicationVndWapWmlc Mime = "application/vnd.wap.wmlc"

	// KMimeApplicationVndWapWmlscriptc
	//
	// English:
	//
	//  Application type 'vnd.wap.wmlscriptc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wap.wmlscriptc'
	KMimeApplicationVndWapWmlscriptc Mime = "application/vnd.wap.wmlscriptc"

	// KMimeApplicationVndWebturbo
	//
	// English:
	//
	//  Application type 'vnd.webturbo'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.webturbo'
	KMimeApplicationVndWebturbo Mime = "application/vnd.webturbo"

	// KMimeApplicationVndWfaDpp
	//
	// English:
	//
	//  Application type 'vnd.wfa.dpp'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wfa.dpp'
	KMimeApplicationVndWfaDpp Mime = "application/vnd.wfa.dpp"

	// KMimeApplicationVndWfaP2p
	//
	// English:
	//
	//  Application type 'vnd.wfa.p2p'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wfa.p2p'
	KMimeApplicationVndWfaP2p Mime = "application/vnd.wfa.p2p"

	// KMimeApplicationVndWfaWsc
	//
	// English:
	//
	//  Application type 'vnd.wfa.wsc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wfa.wsc'
	KMimeApplicationVndWfaWsc Mime = "application/vnd.wfa.wsc"

	// KMimeApplicationVndWindowsDevicepairing
	//
	// English:
	//
	//  Application type 'vnd.windows.devicepairing'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.windows.devicepairing'
	KMimeApplicationVndWindowsDevicepairing Mime = "application/vnd.windows.devicepairing"

	// KMimeApplicationVndWmc
	//
	// English:
	//
	//  Application type 'vnd.wmc'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wmc'
	KMimeApplicationVndWmc Mime = "application/vnd.wmc"

	// KMimeApplicationVndWmfBootstrap
	//
	// English:
	//
	//  Application type 'vnd.wmf.bootstrap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wmf.bootstrap'
	KMimeApplicationVndWmfBootstrap Mime = "application/vnd.wmf.bootstrap"

	// KMimeApplicationVndWolframMathematica
	//
	// English:
	//
	//  Application type 'vnd.wolfram.mathematica'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wolfram.mathematica'
	KMimeApplicationVndWolframMathematica Mime = "application/vnd.wolfram.mathematica"

	// KMimeApplicationVndWolframMathematicaPackage
	//
	// English:
	//
	//  Application type 'vnd.wolfram.mathematica.package'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wolfram.mathematica.package'
	KMimeApplicationVndWolframMathematicaPackage Mime = "application/vnd.wolfram.mathematica.package"

	// KMimeApplicationVndWolframPlayer
	//
	// English:
	//
	//  Application type 'vnd.wolfram.player'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wolfram.player'
	KMimeApplicationVndWolframPlayer Mime = "application/vnd.wolfram.player"

	// KMimeApplicationVndWordperfect
	//
	// English:
	//
	//  Application type 'vnd.wordperfect'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wordperfect'
	KMimeApplicationVndWordperfect Mime = "application/vnd.wordperfect"

	// KMimeApplicationVndWqd
	//
	// English:
	//
	//  Application type 'vnd.wqd'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wqd'
	KMimeApplicationVndWqd Mime = "application/vnd.wqd"

	// KMimeApplicationVndWrqHp3000Labelled
	//
	// English:
	//
	//  Application type 'vnd.wrq-hp3000-labelled'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wrq-hp3000-labelled'
	KMimeApplicationVndWrqHp3000Labelled Mime = "application/vnd.wrq-hp3000-labelled"

	// KMimeApplicationVndWtStf
	//
	// English:
	//
	//  Application type 'vnd.wt.stf'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wt.stf'
	KMimeApplicationVndWtStf Mime = "application/vnd.wt.stf"

	// KMimeApplicationVndWvCspXml
	//
	// English:
	//
	//  Application type 'vnd.wv.csp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wv.csp+xml'
	KMimeApplicationVndWvCspXml Mime = "application/vnd.wv.csp+xml"

	// KMimeApplicationVndWvCspWbxml
	//
	// English:
	//
	//  Application type 'vnd.wv.csp+wbxml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wv.csp+wbxml'
	KMimeApplicationVndWvCspWbxml Mime = "application/vnd.wv.csp+wbxml"

	// KMimeApplicationVndWvSspXml
	//
	// English:
	//
	//  Application type 'vnd.wv.ssp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.wv.ssp+xml'
	KMimeApplicationVndWvSspXml Mime = "application/vnd.wv.ssp+xml"

	// KMimeApplicationVndXacmlJson
	//
	// English:
	//
	//  Application type 'vnd.xacml+json'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xacml+json'
	KMimeApplicationVndXacmlJson Mime = "application/vnd.xacml+json"

	// KMimeApplicationVndXara
	//
	// English:
	//
	//  Application type 'vnd.xara'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xara'
	KMimeApplicationVndXara Mime = "application/vnd.xara"

	// KMimeApplicationVndXfdl
	//
	// English:
	//
	//  Application type 'vnd.xfdl'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xfdl'
	KMimeApplicationVndXfdl Mime = "application/vnd.xfdl"

	// KMimeApplicationVndXfdlWebform
	//
	// English:
	//
	//  Application type 'vnd.xfdl.webform'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xfdl.webform'
	KMimeApplicationVndXfdlWebform Mime = "application/vnd.xfdl.webform"

	// KMimeApplicationVndXmiXml
	//
	// English:
	//
	//  Application type 'vnd.xmi+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmi+xml'
	KMimeApplicationVndXmiXml Mime = "application/vnd.xmi+xml"

	// KMimeApplicationVndXmpieCpkg
	//
	// English:
	//
	//  Application type 'vnd.xmpie.cpkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.cpkg'
	KMimeApplicationVndXmpieCpkg Mime = "application/vnd.xmpie.cpkg"

	// KMimeApplicationVndXmpieDpkg
	//
	// English:
	//
	//  Application type 'vnd.xmpie.dpkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.dpkg'
	KMimeApplicationVndXmpieDpkg Mime = "application/vnd.xmpie.dpkg"

	// KMimeApplicationVndXmpiePlan
	//
	// English:
	//
	//  Application type 'vnd.xmpie.plan'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.plan'
	KMimeApplicationVndXmpiePlan Mime = "application/vnd.xmpie.plan"

	// KMimeApplicationVndXmpiePpkg
	//
	// English:
	//
	//  Application type 'vnd.xmpie.ppkg'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.ppkg'
	KMimeApplicationVndXmpiePpkg Mime = "application/vnd.xmpie.ppkg"

	// KMimeApplicationVndXmpieXlim
	//
	// English:
	//
	//  Application type 'vnd.xmpie.xlim'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.xmpie.xlim'
	KMimeApplicationVndXmpieXlim Mime = "application/vnd.xmpie.xlim"

	// KMimeApplicationVndYamahaHvDic
	//
	// English:
	//
	//  Application type 'vnd.yamaha.hv-dic'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.hv-dic'
	KMimeApplicationVndYamahaHvDic Mime = "application/vnd.yamaha.hv-dic"

	// KMimeApplicationVndYamahaHvScript
	//
	// English:
	//
	//  Application type 'vnd.yamaha.hv-script'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.hv-script'
	KMimeApplicationVndYamahaHvScript Mime = "application/vnd.yamaha.hv-script"

	// KMimeApplicationVndYamahaHvVoice
	//
	// English:
	//
	//  Application type 'vnd.yamaha.hv-voice'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.hv-voice'
	KMimeApplicationVndYamahaHvVoice Mime = "application/vnd.yamaha.hv-voice"

	// KMimeApplicationVndYamahaOpenscoreformatOsfpvgXml
	//
	// English:
	//
	//  Application type 'vnd.yamaha.openscoreformat.osfpvg+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.openscoreformat.osfpvg+xml'
	KMimeApplicationVndYamahaOpenscoreformatOsfpvgXml Mime = "application/vnd.yamaha.openscoreformat.osfpvg+xml"

	// KMimeApplicationVndYamahaOpenscoreformat
	//
	// English:
	//
	//  Application type 'vnd.yamaha.openscoreformat'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.openscoreformat'
	KMimeApplicationVndYamahaOpenscoreformat Mime = "application/vnd.yamaha.openscoreformat"

	// KMimeApplicationVndYamahaRemoteSetup
	//
	// English:
	//
	//  Application type 'vnd.yamaha.remote-setup'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.remote-setup'
	KMimeApplicationVndYamahaRemoteSetup Mime = "application/vnd.yamaha.remote-setup"

	// KMimeApplicationVndYamahaSmafAudio
	//
	// English:
	//
	//  Application type 'vnd.yamaha.smaf-audio'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.smaf-audio'
	KMimeApplicationVndYamahaSmafAudio Mime = "application/vnd.yamaha.smaf-audio"

	// KMimeApplicationVndYamahaSmafPhrase
	//
	// English:
	//
	//  Application type 'vnd.yamaha.smaf-phrase'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.smaf-phrase'
	KMimeApplicationVndYamahaSmafPhrase Mime = "application/vnd.yamaha.smaf-phrase"

	// KMimeApplicationVndYamahaThroughNgn
	//
	// English:
	//
	//  Application type 'vnd.yamaha.through-ngn'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.through-ngn'
	KMimeApplicationVndYamahaThroughNgn Mime = "application/vnd.yamaha.through-ngn"

	// KMimeApplicationVndYamahaTunnelUdpencap
	//
	// English:
	//
	//  Application type 'vnd.yamaha.tunnel-udpencap'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yamaha.tunnel-udpencap'
	KMimeApplicationVndYamahaTunnelUdpencap Mime = "application/vnd.yamaha.tunnel-udpencap"

	// KMimeApplicationVndYaoweme
	//
	// English:
	//
	//  Application type 'vnd.yaoweme'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yaoweme'
	KMimeApplicationVndYaoweme Mime = "application/vnd.yaoweme"

	// KMimeApplicationVndYellowriverCustomMenu
	//
	// English:
	//
	//  Application type 'vnd.yellowriver-custom-menu'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.yellowriver-custom-menu'
	KMimeApplicationVndYellowriverCustomMenu Mime = "application/vnd.yellowriver-custom-menu"

	// KMimeApplicationVndYoutubeYt
	//
	// English:
	//
	//  Application type 'vnd.youtube.yt'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.youtube.yt'
	KMimeApplicationVndYoutubeYt Mime = "(OBSOLETED"

	// KMimeApplicationVndZul
	//
	// English:
	//
	//  Application type 'vnd.zul'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.zul'
	KMimeApplicationVndZul Mime = "application/vnd.zul"

	// KMimeApplicationVndZzazzDeckXml
	//
	// English:
	//
	//  Application type 'vnd.zzazz.deck+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'vnd.zzazz.deck+xml'
	KMimeApplicationVndZzazzDeckXml Mime = "application/vnd.zzazz.deck+xml"

	// KMimeApplicationVoicexmlXml
	//
	// English:
	//
	//  Application type 'voicexml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'voicexml+xml'
	KMimeApplicationVoicexmlXml Mime = "application/voicexml+xml"

	// KMimeApplicationVoucherCmsJson
	//
	// English:
	//
	//  Application type 'voucher-cms+json'
	//
	// Português:
	//
	//  Aplicação tipo 'voucher-cms+json'
	KMimeApplicationVoucherCmsJson Mime = "application/voucher-cms+json"

	// KMimeApplicationVqRtcpxr
	//
	// English:
	//
	//  Application type 'vq-rtcpxr'
	//
	// Português:
	//
	//  Aplicação tipo 'vq-rtcpxr'
	KMimeApplicationVqRtcpxr Mime = "application/vq-rtcpxr"

	// KMimeApplicationWasm
	//
	// English:
	//
	//  Application type 'wasm'
	//
	// Português:
	//
	//  Aplicação tipo 'wasm'
	KMimeApplicationWasm Mime = "application/wasm"

	// KMimeApplicationWatcherinfoXml
	//
	// English:
	//
	//  Application type 'watcherinfo+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'watcherinfo+xml'
	KMimeApplicationWatcherinfoXml Mime = "application/watcherinfo+xml"

	// KMimeApplicationWebpushOptionsJson
	//
	// English:
	//
	//  Application type 'webpush-options+json'
	//
	// Português:
	//
	//  Aplicação tipo 'webpush-options+json'
	KMimeApplicationWebpushOptionsJson Mime = "application/webpush-options+json"

	// KMimeApplicationWhoisppQuery
	//
	// English:
	//
	//  Application type 'whoispp-query'
	//
	// Português:
	//
	//  Aplicação tipo 'whoispp-query'
	KMimeApplicationWhoisppQuery Mime = "application/whoispp-query"

	// KMimeApplicationWhoisppResponse
	//
	// English:
	//
	//  Application type 'whoispp-response'
	//
	// Português:
	//
	//  Aplicação tipo 'whoispp-response'
	KMimeApplicationWhoisppResponse Mime = "application/whoispp-response"

	// KMimeApplicationWidget
	//
	// English:
	//
	//  Application type 'widget'
	//
	// Português:
	//
	//  Aplicação tipo 'widget'
	KMimeApplicationWidget Mime = "application/widget"

	// KMimeApplicationWita
	//
	// English:
	//
	//  Application type 'wita'
	//
	// Português:
	//
	//  Aplicação tipo 'wita'
	KMimeApplicationWita Mime = "application/wita"

	// KMimeApplicationWordperfect51
	//
	// English:
	//
	//  Application type 'wordperfect5.1'
	//
	// Português:
	//
	//  Aplicação tipo 'wordperfect5.1'
	KMimeApplicationWordperfect51 Mime = "application/wordperfect5.1"

	// KMimeApplicationWsdlXml
	//
	// English:
	//
	//  Application type 'wsdl+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'wsdl+xml'
	KMimeApplicationWsdlXml Mime = "application/wsdl+xml"

	// KMimeApplicationWspolicyXml
	//
	// English:
	//
	//  Application type 'wspolicy+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'wspolicy+xml'
	KMimeApplicationWspolicyXml Mime = "application/wspolicy+xml"

	// KMimeApplicationXPkiMessage
	//
	// English:
	//
	//  Application type 'x-pki-message'
	//
	// Português:
	//
	//  Aplicação tipo 'x-pki-message'
	KMimeApplicationXPkiMessage Mime = "application/x-pki-message"

	// KMimeApplicationXWwwFormUrlencoded
	//
	// English:
	//
	//  Application type 'x-www-form-urlencoded'
	//
	// Português:
	//
	//  Aplicação tipo 'x-www-form-urlencoded'
	KMimeApplicationXWwwFormUrlencoded Mime = "application/x-www-form-urlencoded"

	// KMimeApplicationXX509CaCert
	//
	// English:
	//
	//  Application type 'x-x509-ca-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'x-x509-ca-cert'
	KMimeApplicationXX509CaCert Mime = "application/x-x509-ca-cert"

	// KMimeApplicationXX509CaRaCert
	//
	// English:
	//
	//  Application type 'x-x509-ca-ra-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'x-x509-ca-ra-cert'
	KMimeApplicationXX509CaRaCert Mime = "application/x-x509-ca-ra-cert"

	// KMimeApplicationXX509NextCaCert
	//
	// English:
	//
	//  Application type 'x-x509-next-ca-cert'
	//
	// Português:
	//
	//  Aplicação tipo 'x-x509-next-ca-cert'
	KMimeApplicationXX509NextCaCert Mime = "application/x-x509-next-ca-cert"

	// KMimeApplicationX400Bp
	//
	// English:
	//
	//  Application type 'x400-bp'
	//
	// Português:
	//
	//  Aplicação tipo 'x400-bp'
	KMimeApplicationX400Bp Mime = "application/x400-bp"

	// KMimeApplicationXacmlXml
	//
	// English:
	//
	//  Application type 'xacml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xacml+xml'
	KMimeApplicationXacmlXml Mime = "application/xacml+xml"

	// KMimeApplicationXcapAttXml
	//
	// English:
	//
	//  Application type 'xcap-att+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-att+xml'
	KMimeApplicationXcapAttXml Mime = "application/xcap-att+xml"

	// KMimeApplicationXcapCapsXml
	//
	// English:
	//
	//  Application type 'xcap-caps+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-caps+xml'
	KMimeApplicationXcapCapsXml Mime = "application/xcap-caps+xml"

	// KMimeApplicationXcapDiffXml
	//
	// English:
	//
	//  Application type 'xcap-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-diff+xml'
	KMimeApplicationXcapDiffXml Mime = "application/xcap-diff+xml"

	// KMimeApplicationXcapElXml
	//
	// English:
	//
	//  Application type 'xcap-el+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-el+xml'
	KMimeApplicationXcapElXml Mime = "application/xcap-el+xml"

	// KMimeApplicationXcapErrorXml
	//
	// English:
	//
	//  Application type 'xcap-error+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-error+xml'
	KMimeApplicationXcapErrorXml Mime = "application/xcap-error+xml"

	// KMimeApplicationXcapNsXml
	//
	// English:
	//
	//  Application type 'xcap-ns+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcap-ns+xml'
	KMimeApplicationXcapNsXml Mime = "application/xcap-ns+xml"

	// KMimeApplicationXconConferenceInfoDiffXml
	//
	// English:
	//
	//  Application type 'xcon-conference-info-diff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcon-conference-info-diff+xml'
	KMimeApplicationXconConferenceInfoDiffXml Mime = "application/xcon-conference-info-diff+xml"

	// KMimeApplicationXconConferenceInfoXml
	//
	// English:
	//
	//  Application type 'xcon-conference-info+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xcon-conference-info+xml'
	KMimeApplicationXconConferenceInfoXml Mime = "application/xcon-conference-info+xml"

	// KMimeApplicationXencXml
	//
	// English:
	//
	//  Application type 'xenc+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xenc+xml'
	KMimeApplicationXencXml Mime = "application/xenc+xml"

	// KMimeApplicationXhtmlXml
	//
	// English:
	//
	//  Application type 'xhtml+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xhtml+xml'
	KMimeApplicationXhtmlXml Mime = "application/xhtml+xml"

	// KMimeApplicationXliffXml
	//
	// English:
	//
	//  Application type 'xliff+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xliff+xml'
	KMimeApplicationXliffXml Mime = "application/xliff+xml"

	// KMimeApplicationXml
	//
	// English:
	//
	//  Application type 'xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xml'
	KMimeApplicationXml Mime = "application/xml"

	// KMimeApplicationXmlDtd
	//
	// English:
	//
	//  Application type 'xml-dtd'
	//
	// Português:
	//
	//  Aplicação tipo 'xml-dtd'
	KMimeApplicationXmlDtd Mime = "application/xml-dtd"

	// KMimeApplicationXmlExternalParsedEntity
	//
	// English:
	//
	//  Application type 'xml-external-parsed-entity'
	//
	// Português:
	//
	//  Aplicação tipo 'xml-external-parsed-entity'
	KMimeApplicationXmlExternalParsedEntity Mime = "application/xml-external-parsed-entity"

	// KMimeApplicationXmlPatchXml
	//
	// English:
	//
	//  Application type 'xml-patch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xml-patch+xml'
	KMimeApplicationXmlPatchXml Mime = "application/xml-patch+xml"

	// KMimeApplicationXmppXml
	//
	// English:
	//
	//  Application type 'xmpp+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xmpp+xml'
	KMimeApplicationXmppXml Mime = "application/xmpp+xml"

	// KMimeApplicationXopXml
	//
	// English:
	//
	//  Application type 'xop+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xop+xml'
	KMimeApplicationXopXml Mime = "application/xop+xml"

	// KMimeApplicationXsltXml
	//
	// English:
	//
	//  Application type 'xslt+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xslt+xml'
	KMimeApplicationXsltXml Mime = "application/xslt+xml"

	// KMimeApplicationXvXml
	//
	// English:
	//
	//  Application type 'xv+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'xv+xml'
	KMimeApplicationXvXml Mime = "application/xv+xml"

	// KMimeApplicationYang
	//
	// English:
	//
	//  Application type 'yang'
	//
	// Português:
	//
	//  Aplicação tipo 'yang'
	KMimeApplicationYang Mime = "application/yang"

	// KMimeApplicationYangDataCbor
	//
	// English:
	//
	//  Application type 'yang-data+cbor'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-data+cbor'
	KMimeApplicationYangDataCbor Mime = "application/yang-data+cbor"

	// KMimeApplicationYangDataJson
	//
	// English:
	//
	//  Application type 'yang-data+json'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-data+json'
	KMimeApplicationYangDataJson Mime = "application/yang-data+json"

	// KMimeApplicationYangDataXml
	//
	// English:
	//
	//  Application type 'yang-data+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-data+xml'
	KMimeApplicationYangDataXml Mime = "application/yang-data+xml"

	// KMimeApplicationYangPatchJson
	//
	// English:
	//
	//  Application type 'yang-patch+json'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-patch+json'
	KMimeApplicationYangPatchJson Mime = "application/yang-patch+json"

	// KMimeApplicationYangPatchXml
	//
	// English:
	//
	//  Application type 'yang-patch+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'yang-patch+xml'
	KMimeApplicationYangPatchXml Mime = "application/yang-patch+xml"

	// KMimeApplicationYinXml
	//
	// English:
	//
	//  Application type 'yin+xml'
	//
	// Português:
	//
	//  Aplicação tipo 'yin+xml'
	KMimeApplicationYinXml Mime = "application/yin+xml"

	// KMimeApplicationZip
	//
	// English:
	//
	//  Application type 'zip'
	//
	// Português:
	//
	//  Aplicação tipo 'zip'
	KMimeApplicationZip Mime = "application/zip"

	// KMimeApplicationZlib
	//
	// English:
	//
	//  Application type 'zlib'
	//
	// Português:
	//
	//  Aplicação tipo 'zlib'
	KMimeApplicationZlib Mime = "application/zlib"

	// KMimeApplicationZstd
	//
	// English:
	//
	//  Application type 'zstd'
	//
	// Português:
	//
	//  Aplicação tipo 'zstd'
	KMimeApplicationZstd Mime = "application/zstd"
)
const (
	// KMimeAudio1dInterleavedParityfec
	//
	// English:
	//
	//  Audio type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Audio tipo '1d-interleaved-parityfec'
	KMimeAudio1dInterleavedParityfec Mime = "audio/1d-interleaved-parityfec"

	// KMimeAudio32kadpcm
	//
	// English:
	//
	//  Audio type '32kadpcm'
	//
	// Português:
	//
	//  Audio tipo '32kadpcm'
	KMimeAudio32kadpcm Mime = "audio/32kadpcm"

	// KMimeAudio3gpp
	//
	// English:
	//
	//  Audio type '3gpp'
	//
	// Português:
	//
	//  Audio tipo '3gpp'
	KMimeAudio3gpp Mime = "audio/3gpp"

	// KMimeAudio3gpp2
	//
	// English:
	//
	//  Audio type '3gpp2'
	//
	// Português:
	//
	//  Audio tipo '3gpp2'
	KMimeAudio3gpp2 Mime = "audio/3gpp2"

	// KMimeAudioAac
	//
	// English:
	//
	//  Audio type 'aac'
	//
	// Português:
	//
	//  Audio tipo 'aac'
	KMimeAudioAac Mime = "audio/aac"

	// KMimeAudioAc3
	//
	// English:
	//
	//  Audio type 'ac3'
	//
	// Português:
	//
	//  Audio tipo 'ac3'
	KMimeAudioAc3 Mime = "audio/ac3"

	// KMimeAudioAMR
	//
	// English:
	//
	//  Audio type 'AMR'
	//
	// Português:
	//
	//  Audio tipo 'AMR'
	KMimeAudioAMR Mime = "audio/AMR"

	// KMimeAudioAMRWB
	//
	// English:
	//
	//  Audio type 'AMR-WB'
	//
	// Português:
	//
	//  Audio tipo 'AMR-WB'
	KMimeAudioAMRWB Mime = "audio/AMR-WB"

	// KMimeAudioAmrWb
	//
	// English:
	//
	//  Audio type 'amr-wb+'
	//
	// Português:
	//
	//  Audio tipo 'amr-wb+'
	KMimeAudioAmrWb Mime = "audio/amr-wb+"

	// KMimeAudioAptx
	//
	// English:
	//
	//  Audio type 'aptx'
	//
	// Português:
	//
	//  Audio tipo 'aptx'
	KMimeAudioAptx Mime = "audio/aptx"

	// KMimeAudioAsc
	//
	// English:
	//
	//  Audio type 'asc'
	//
	// Português:
	//
	//  Audio tipo 'asc'
	KMimeAudioAsc Mime = "audio/asc"

	// KMimeAudioATRACADVANCEDLOSSLESS
	//
	// English:
	//
	//  Audio type 'ATRAC-ADVANCED-LOSSLESS'
	//
	// Português:
	//
	//  Audio tipo 'ATRAC-ADVANCED-LOSSLESS'
	KMimeAudioATRACADVANCEDLOSSLESS Mime = "audio/ATRAC-ADVANCED-LOSSLESS"

	// KMimeAudioATRACX
	//
	// English:
	//
	//  Audio type 'ATRAC-X'
	//
	// Português:
	//
	//  Audio tipo 'ATRAC-X'
	KMimeAudioATRACX Mime = "audio/ATRAC-X"

	// KMimeAudioATRAC3
	//
	// English:
	//
	//  Audio type 'ATRAC3'
	//
	// Português:
	//
	//  Audio tipo 'ATRAC3'
	KMimeAudioATRAC3 Mime = "audio/ATRAC3"

	// KMimeAudioBasic
	//
	// English:
	//
	//  Audio type 'basic'
	//
	// Português:
	//
	//  Audio tipo 'basic'
	KMimeAudioBasic Mime = "audio/basic"

	// KMimeAudioBV16
	//
	// English:
	//
	//  Audio type 'BV16'
	//
	// Português:
	//
	//  Audio tipo 'BV16'
	KMimeAudioBV16 Mime = "audio/BV16"

	// KMimeAudioBV32
	//
	// English:
	//
	//  Audio type 'BV32'
	//
	// Português:
	//
	//  Audio tipo 'BV32'
	KMimeAudioBV32 Mime = "audio/BV32"

	// KMimeAudioClearmode
	//
	// English:
	//
	//  Audio type 'clearmode'
	//
	// Português:
	//
	//  Audio tipo 'clearmode'
	KMimeAudioClearmode Mime = "audio/clearmode"

	// KMimeAudioCN
	//
	// English:
	//
	//  Audio type 'CN'
	//
	// Português:
	//
	//  Audio tipo 'CN'
	KMimeAudioCN Mime = "audio/CN"

	// KMimeAudioDAT12
	//
	// English:
	//
	//  Audio type 'DAT12'
	//
	// Português:
	//
	//  Audio tipo 'DAT12'
	KMimeAudioDAT12 Mime = "audio/DAT12"

	// KMimeAudioDls
	//
	// English:
	//
	//  Audio type 'dls'
	//
	// Português:
	//
	//  Audio tipo 'dls'
	KMimeAudioDls Mime = "audio/dls"

	// KMimeAudioDsrEs201108
	//
	// English:
	//
	//  Audio type 'dsr-es201108'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es201108'
	KMimeAudioDsrEs201108 Mime = "audio/dsr-es201108"

	// KMimeAudioDsrEs202050
	//
	// English:
	//
	//  Audio type 'dsr-es202050'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es202050'
	KMimeAudioDsrEs202050 Mime = "audio/dsr-es202050"

	// KMimeAudioDsrEs202211
	//
	// English:
	//
	//  Audio type 'dsr-es202211'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es202211'
	KMimeAudioDsrEs202211 Mime = "audio/dsr-es202211"

	// KMimeAudioDsrEs202212
	//
	// English:
	//
	//  Audio type 'dsr-es202212'
	//
	// Português:
	//
	//  Audio tipo 'dsr-es202212'
	KMimeAudioDsrEs202212 Mime = "audio/dsr-es202212"

	// KMimeAudioDV
	//
	// English:
	//
	//  Audio type 'DV'
	//
	// Português:
	//
	//  Audio tipo 'DV'
	KMimeAudioDV Mime = "audio/DV"

	// KMimeAudioDVI4
	//
	// English:
	//
	//  Audio type 'DVI4'
	//
	// Português:
	//
	//  Audio tipo 'DVI4'
	KMimeAudioDVI4 Mime = "audio/DVI4"

	// KMimeAudioEac3
	//
	// English:
	//
	//  Audio type 'eac3'
	//
	// Português:
	//
	//  Audio tipo 'eac3'
	KMimeAudioEac3 Mime = "audio/eac3"

	// KMimeAudioEncaprtp
	//
	// English:
	//
	//  Audio type 'encaprtp'
	//
	// Português:
	//
	//  Audio tipo 'encaprtp'
	KMimeAudioEncaprtp Mime = "audio/encaprtp"

	// KMimeAudioEVRC
	//
	// English:
	//
	//  Audio type 'EVRC'
	//
	// Português:
	//
	//  Audio tipo 'EVRC'
	KMimeAudioEVRC Mime = "audio/EVRC"

	// KMimeAudioEVRCQCP
	//
	// English:
	//
	//  Audio type 'EVRC-QCP'
	//
	// Português:
	//
	//  Audio tipo 'EVRC-QCP'
	KMimeAudioEVRCQCP Mime = "audio/EVRC-QCP"

	// KMimeAudioEVRC0
	//
	// English:
	//
	//  Audio type 'EVRC0'
	//
	// Português:
	//
	//  Audio tipo 'EVRC0'
	KMimeAudioEVRC0 Mime = "audio/EVRC0"

	// KMimeAudioEVRC1
	//
	// English:
	//
	//  Audio type 'EVRC1'
	//
	// Português:
	//
	//  Audio tipo 'EVRC1'
	KMimeAudioEVRC1 Mime = "audio/EVRC1"

	// KMimeAudioEVRCB
	//
	// English:
	//
	//  Audio type 'EVRCB'
	//
	// Português:
	//
	//  Audio tipo 'EVRCB'
	KMimeAudioEVRCB Mime = "audio/EVRCB"

	// KMimeAudioEVRCB0
	//
	// English:
	//
	//  Audio type 'EVRCB0'
	//
	// Português:
	//
	//  Audio tipo 'EVRCB0'
	KMimeAudioEVRCB0 Mime = "audio/EVRCB0"

	// KMimeAudioEVRCB1
	//
	// English:
	//
	//  Audio type 'EVRCB1'
	//
	// Português:
	//
	//  Audio tipo 'EVRCB1'
	KMimeAudioEVRCB1 Mime = "audio/EVRCB1"

	// KMimeAudioEVRCNW
	//
	// English:
	//
	//  Audio type 'EVRCNW'
	//
	// Português:
	//
	//  Audio tipo 'EVRCNW'
	KMimeAudioEVRCNW Mime = "audio/EVRCNW"

	// KMimeAudioEVRCNW0
	//
	// English:
	//
	//  Audio type 'EVRCNW0'
	//
	// Português:
	//
	//  Audio tipo 'EVRCNW0'
	KMimeAudioEVRCNW0 Mime = "audio/EVRCNW0"

	// KMimeAudioEVRCNW1
	//
	// English:
	//
	//  Audio type 'EVRCNW1'
	//
	// Português:
	//
	//  Audio tipo 'EVRCNW1'
	KMimeAudioEVRCNW1 Mime = "audio/EVRCNW1"

	// KMimeAudioEVRCWB
	//
	// English:
	//
	//  Audio type 'EVRCWB'
	//
	// Português:
	//
	//  Audio tipo 'EVRCWB'
	KMimeAudioEVRCWB Mime = "audio/EVRCWB"

	// KMimeAudioEVRCWB0
	//
	// English:
	//
	//  Audio type 'EVRCWB0'
	//
	// Português:
	//
	//  Audio tipo 'EVRCWB0'
	KMimeAudioEVRCWB0 Mime = "audio/EVRCWB0"

	// KMimeAudioEVRCWB1
	//
	// English:
	//
	//  Audio type 'EVRCWB1'
	//
	// Português:
	//
	//  Audio tipo 'EVRCWB1'
	KMimeAudioEVRCWB1 Mime = "audio/EVRCWB1"

	// KMimeAudioEVS
	//
	// English:
	//
	//  Audio type 'EVS'
	//
	// Português:
	//
	//  Audio tipo 'EVS'
	KMimeAudioEVS Mime = "audio/EVS"

	// KMimeAudioExample
	//
	// English:
	//
	//  Audio type 'example'
	//
	// Português:
	//
	//  Audio tipo 'example'
	KMimeAudioExample Mime = "audio/example"

	// KMimeAudioFlexfec
	//
	// English:
	//
	//  Audio type 'flexfec'
	//
	// Português:
	//
	//  Audio tipo 'flexfec'
	KMimeAudioFlexfec Mime = "audio/flexfec"

	// KMimeAudioFwdred
	//
	// English:
	//
	//  Audio type 'fwdred'
	//
	// Português:
	//
	//  Audio tipo 'fwdred'
	KMimeAudioFwdred Mime = "audio/fwdred"

	// KMimeAudioG7110
	//
	// English:
	//
	//  Audio type 'G711-0'
	//
	// Português:
	//
	//  Audio tipo 'G711-0'
	KMimeAudioG7110 Mime = "audio/G711-0"

	// KMimeAudioG719
	//
	// English:
	//
	//  Audio type 'G719'
	//
	// Português:
	//
	//  Audio tipo 'G719'
	KMimeAudioG719 Mime = "audio/G719"

	// KMimeAudioG7221
	//
	// English:
	//
	//  Audio type 'G7221'
	//
	// Português:
	//
	//  Audio tipo 'G7221'
	KMimeAudioG7221 Mime = "audio/G7221"

	// KMimeAudioG722
	//
	// English:
	//
	//  Audio type 'G722'
	//
	// Português:
	//
	//  Audio tipo 'G722'
	KMimeAudioG722 Mime = "audio/G722"

	// KMimeAudioG723
	//
	// English:
	//
	//  Audio type 'G723'
	//
	// Português:
	//
	//  Audio tipo 'G723'
	KMimeAudioG723 Mime = "audio/G723"

	// KMimeAudioG72616
	//
	// English:
	//
	//  Audio type 'G726-16'
	//
	// Português:
	//
	//  Audio tipo 'G726-16'
	KMimeAudioG72616 Mime = "audio/G726-16"

	// KMimeAudioG72624
	//
	// English:
	//
	//  Audio type 'G726-24'
	//
	// Português:
	//
	//  Audio tipo 'G726-24'
	KMimeAudioG72624 Mime = "audio/G726-24"

	// KMimeAudioG72632
	//
	// English:
	//
	//  Audio type 'G726-32'
	//
	// Português:
	//
	//  Audio tipo 'G726-32'
	KMimeAudioG72632 Mime = "audio/G726-32"

	// KMimeAudioG72640
	//
	// English:
	//
	//  Audio type 'G726-40'
	//
	// Português:
	//
	//  Audio tipo 'G726-40'
	KMimeAudioG72640 Mime = "audio/G726-40"

	// KMimeAudioG728
	//
	// English:
	//
	//  Audio type 'G728'
	//
	// Português:
	//
	//  Audio tipo 'G728'
	KMimeAudioG728 Mime = "audio/G728"

	// KMimeAudioG729
	//
	// English:
	//
	//  Audio type 'G729'
	//
	// Português:
	//
	//  Audio tipo 'G729'
	KMimeAudioG729 Mime = "audio/G729"

	// KMimeAudioG7291
	//
	// English:
	//
	//  Audio type 'G7291'
	//
	// Português:
	//
	//  Audio tipo 'G7291'
	KMimeAudioG7291 Mime = "audio/G7291"

	// KMimeAudioG729D
	//
	// English:
	//
	//  Audio type 'G729D'
	//
	// Português:
	//
	//  Audio tipo 'G729D'
	KMimeAudioG729D Mime = "audio/G729D"

	// KMimeAudioG729E
	//
	// English:
	//
	//  Audio type 'G729E'
	//
	// Português:
	//
	//  Audio tipo 'G729E'
	KMimeAudioG729E Mime = "audio/G729E"

	// KMimeAudioGSM
	//
	// English:
	//
	//  Audio type 'GSM'
	//
	// Português:
	//
	//  Audio tipo 'GSM'
	KMimeAudioGSM Mime = "audio/GSM"

	// KMimeAudioGSMEFR
	//
	// English:
	//
	//  Audio type 'GSM-EFR'
	//
	// Português:
	//
	//  Audio tipo 'GSM-EFR'
	KMimeAudioGSMEFR Mime = "audio/GSM-EFR"

	// KMimeAudioGSMHR08
	//
	// English:
	//
	//  Audio type 'GSM-HR-08'
	//
	// Português:
	//
	//  Audio tipo 'GSM-HR-08'
	KMimeAudioGSMHR08 Mime = "audio/GSM-HR-08"

	// KMimeAudioILBC
	//
	// English:
	//
	//  Audio type 'iLBC'
	//
	// Português:
	//
	//  Audio tipo 'iLBC'
	KMimeAudioILBC Mime = "audio/iLBC"

	// KMimeAudioIpMrV25
	//
	// English:
	//
	//  Audio type 'ip-mr_v2.5'
	//
	// Português:
	//
	//  Audio tipo 'ip-mr_v2.5'
	KMimeAudioIpMrV25 Mime = "audio/ip-mr_v2.5"

	// KMimeAudioL8
	//
	// English:
	//
	//  Audio type 'L8'
	//
	// Português:
	//
	//  Audio tipo 'L8'
	KMimeAudioL8 Mime = "audio/L8"

	// KMimeAudioL16
	//
	// English:
	//
	//  Audio type 'L16'
	//
	// Português:
	//
	//  Audio tipo 'L16'
	KMimeAudioL16 Mime = "audio/L16"

	// KMimeAudioL20
	//
	// English:
	//
	//  Audio type 'L20'
	//
	// Português:
	//
	//  Audio tipo 'L20'
	KMimeAudioL20 Mime = "audio/L20"

	// KMimeAudioL24
	//
	// English:
	//
	//  Audio type 'L24'
	//
	// Português:
	//
	//  Audio tipo 'L24'
	KMimeAudioL24 Mime = "audio/L24"

	// KMimeAudioLPC
	//
	// English:
	//
	//  Audio type 'LPC'
	//
	// Português:
	//
	//  Audio tipo 'LPC'
	KMimeAudioLPC Mime = "audio/LPC"

	// KMimeAudioMELP
	//
	// English:
	//
	//  Audio type 'MELP'
	//
	// Português:
	//
	//  Audio tipo 'MELP'
	KMimeAudioMELP Mime = "audio/MELP"

	// KMimeAudioMELP600
	//
	// English:
	//
	//  Audio type 'MELP600'
	//
	// Português:
	//
	//  Audio tipo 'MELP600'
	KMimeAudioMELP600 Mime = "audio/MELP600"

	// KMimeAudioMELP1200
	//
	// English:
	//
	//  Audio type 'MELP1200'
	//
	// Português:
	//
	//  Audio tipo 'MELP1200'
	KMimeAudioMELP1200 Mime = "audio/MELP1200"

	// KMimeAudioMELP2400
	//
	// English:
	//
	//  Audio type 'MELP2400'
	//
	// Português:
	//
	//  Audio tipo 'MELP2400'
	KMimeAudioMELP2400 Mime = "audio/MELP2400"

	// KMimeAudioMhas
	//
	// English:
	//
	//  Audio type 'mhas'
	//
	// Português:
	//
	//  Audio tipo 'mhas'
	KMimeAudioMhas Mime = "audio/mhas"

	// KMimeAudioMobileXmf
	//
	// English:
	//
	//  Audio type 'mobile-xmf'
	//
	// Português:
	//
	//  Audio tipo 'mobile-xmf'
	KMimeAudioMobileXmf Mime = "audio/mobile-xmf"

	// KMimeAudioMPA
	//
	// English:
	//
	//  Audio type 'MPA'
	//
	// Português:
	//
	//  Audio tipo 'MPA'
	KMimeAudioMPA Mime = "audio/MPA"

	// KMimeAudioMp4
	//
	// English:
	//
	//  Audio type 'mp4'
	//
	// Português:
	//
	//  Audio tipo 'mp4'
	KMimeAudioMp4 Mime = "audio/mp4"

	// KMimeAudioMP4ALATM
	//
	// English:
	//
	//  Audio type 'MP4A-LATM'
	//
	// Português:
	//
	//  Audio tipo 'MP4A-LATM'
	KMimeAudioMP4ALATM Mime = "audio/MP4A-LATM"

	// KMimeAudioMpaRobust
	//
	// English:
	//
	//  Audio type 'mpa-robust'
	//
	// Português:
	//
	//  Audio tipo 'mpa-robust'
	KMimeAudioMpaRobust Mime = "audio/mpa-robust"

	// KMimeAudioMpeg
	//
	// English:
	//
	//  Audio type 'mpeg'
	//
	// Português:
	//
	//  Audio tipo 'mpeg'
	KMimeAudioMpeg Mime = "audio/mpeg"

	// KMimeAudioMpeg4Generic
	//
	// English:
	//
	//  Audio type 'mpeg4-generic'
	//
	// Português:
	//
	//  Audio tipo 'mpeg4-generic'
	KMimeAudioMpeg4Generic Mime = "audio/mpeg4-generic"

	// KMimeAudioOgg
	//
	// English:
	//
	//  Audio type 'ogg'
	//
	// Português:
	//
	//  Audio tipo 'ogg'
	KMimeAudioOgg Mime = "audio/ogg"

	// KMimeAudioOpus
	//
	// English:
	//
	//  Audio type 'opus'
	//
	// Português:
	//
	//  Audio tipo 'opus'
	KMimeAudioOpus Mime = "audio/opus"

	// KMimeAudioParityfec
	//
	// English:
	//
	//  Audio type 'parityfec'
	//
	// Português:
	//
	//  Audio tipo 'parityfec'
	KMimeAudioParityfec Mime = "audio/parityfec"

	// KMimeAudioPCMA
	//
	// English:
	//
	//  Audio type 'PCMA'
	//
	// Português:
	//
	//  Audio tipo 'PCMA'
	KMimeAudioPCMA Mime = "audio/PCMA"

	// KMimeAudioPCMAWB
	//
	// English:
	//
	//  Audio type 'PCMA-WB'
	//
	// Português:
	//
	//  Audio tipo 'PCMA-WB'
	KMimeAudioPCMAWB Mime = "audio/PCMA-WB"

	// KMimeAudioPCMU
	//
	// English:
	//
	//  Audio type 'PCMU'
	//
	// Português:
	//
	//  Audio tipo 'PCMU'
	KMimeAudioPCMU Mime = "audio/PCMU"

	// KMimeAudioPCMUWB
	//
	// English:
	//
	//  Audio type 'PCMU-WB'
	//
	// Português:
	//
	//  Audio tipo 'PCMU-WB'
	KMimeAudioPCMUWB Mime = "audio/PCMU-WB"

	// KMimeAudioPrsSid
	//
	// English:
	//
	//  Audio type 'prs.sid'
	//
	// Português:
	//
	//  Audio tipo 'prs.sid'
	KMimeAudioPrsSid Mime = "audio/prs.sid"

	// KMimeAudioQCELP
	//
	// English:
	//
	//  Audio type 'QCELP'
	//
	// Português:
	//
	//  Audio tipo 'QCELP'
	KMimeAudioQCELP Mime = "audio/QCELP"

	// KMimeAudioRaptorfec
	//
	// English:
	//
	//  Audio type 'raptorfec'
	//
	// Português:
	//
	//  Audio tipo 'raptorfec'
	KMimeAudioRaptorfec Mime = "audio/raptorfec"

	// KMimeAudioRED
	//
	// English:
	//
	//  Audio type 'RED'
	//
	// Português:
	//
	//  Audio tipo 'RED'
	KMimeAudioRED Mime = "audio/RED"

	// KMimeAudioRtpEncAescm128
	//
	// English:
	//
	//  Audio type 'rtp-enc-aescm128'
	//
	// Português:
	//
	//  Audio tipo 'rtp-enc-aescm128'
	KMimeAudioRtpEncAescm128 Mime = "audio/rtp-enc-aescm128"

	// KMimeAudioRtploopback
	//
	// English:
	//
	//  Audio type 'rtploopback'
	//
	// Português:
	//
	//  Audio tipo 'rtploopback'
	KMimeAudioRtploopback Mime = "audio/rtploopback"

	// KMimeAudioRtpMidi
	//
	// English:
	//
	//  Audio type 'rtp-midi'
	//
	// Português:
	//
	//  Audio tipo 'rtp-midi'
	KMimeAudioRtpMidi Mime = "audio/rtp-midi"

	// KMimeAudioRtx
	//
	// English:
	//
	//  Audio type 'rtx'
	//
	// Português:
	//
	//  Audio tipo 'rtx'
	KMimeAudioRtx Mime = "audio/rtx"

	// KMimeAudioScip
	//
	// English:
	//
	//  Audio type 'scip'
	//
	// Português:
	//
	//  Audio tipo 'scip'
	KMimeAudioScip Mime = "audio/scip"

	// KMimeAudioSMV
	//
	// English:
	//
	//  Audio type 'SMV'
	//
	// Português:
	//
	//  Audio tipo 'SMV'
	KMimeAudioSMV Mime = "audio/SMV"

	// KMimeAudioSMV0
	//
	// English:
	//
	//  Audio type 'SMV0'
	//
	// Português:
	//
	//  Audio tipo 'SMV0'
	KMimeAudioSMV0 Mime = "audio/SMV0"

	// KMimeAudioSMVQCP
	//
	// English:
	//
	//  Audio type 'SMV-QCP'
	//
	// Português:
	//
	//  Audio tipo 'SMV-QCP'
	KMimeAudioSMVQCP Mime = "audio/SMV-QCP"

	// KMimeAudioSofa
	//
	// English:
	//
	//  Audio type 'sofa'
	//
	// Português:
	//
	//  Audio tipo 'sofa'
	KMimeAudioSofa Mime = "audio/sofa"

	// KMimeAudioSpMidi
	//
	// English:
	//
	//  Audio type 'sp-midi'
	//
	// Português:
	//
	//  Audio tipo 'sp-midi'
	KMimeAudioSpMidi Mime = "audio/sp-midi"

	// KMimeAudioSpeex
	//
	// English:
	//
	//  Audio type 'speex'
	//
	// Português:
	//
	//  Audio tipo 'speex'
	KMimeAudioSpeex Mime = "audio/speex"

	// KMimeAudioT140c
	//
	// English:
	//
	//  Audio type 't140c'
	//
	// Português:
	//
	//  Audio tipo 't140c'
	KMimeAudioT140c Mime = "audio/t140c"

	// KMimeAudioT38
	//
	// English:
	//
	//  Audio type 't38'
	//
	// Português:
	//
	//  Audio tipo 't38'
	KMimeAudioT38 Mime = "audio/t38"

	// KMimeAudioTelephoneEvent
	//
	// English:
	//
	//  Audio type 'telephone-event'
	//
	// Português:
	//
	//  Audio tipo 'telephone-event'
	KMimeAudioTelephoneEvent Mime = "audio/telephone-event"

	// KMimeAudioTETRAACELP
	//
	// English:
	//
	//  Audio type 'TETRA_ACELP'
	//
	// Português:
	//
	//  Audio tipo 'TETRA_ACELP'
	KMimeAudioTETRAACELP Mime = "audio/TETRA_ACELP"

	// KMimeAudioTETRAACELPBB
	//
	// English:
	//
	//  Audio type 'TETRA_ACELP_BB'
	//
	// Português:
	//
	//  Audio tipo 'TETRA_ACELP_BB'
	KMimeAudioTETRAACELPBB Mime = "audio/TETRA_ACELP_BB"

	// KMimeAudioTone
	//
	// English:
	//
	//  Audio type 'tone'
	//
	// Português:
	//
	//  Audio tipo 'tone'
	KMimeAudioTone Mime = "audio/tone"

	// KMimeAudioTSVCIS
	//
	// English:
	//
	//  Audio type 'TSVCIS'
	//
	// Português:
	//
	//  Audio tipo 'TSVCIS'
	KMimeAudioTSVCIS Mime = "audio/TSVCIS"

	// KMimeAudioUEMCLIP
	//
	// English:
	//
	//  Audio type 'UEMCLIP'
	//
	// Português:
	//
	//  Audio tipo 'UEMCLIP'
	KMimeAudioUEMCLIP Mime = "audio/UEMCLIP"

	// KMimeAudioUlpfec
	//
	// English:
	//
	//  Audio type 'ulpfec'
	//
	// Português:
	//
	//  Audio tipo 'ulpfec'
	KMimeAudioUlpfec Mime = "audio/ulpfec"

	// KMimeAudioUsac
	//
	// English:
	//
	//  Audio type 'usac'
	//
	// Português:
	//
	//  Audio tipo 'usac'
	KMimeAudioUsac Mime = "audio/usac"

	// KMimeAudioVDVI
	//
	// English:
	//
	//  Audio type 'VDVI'
	//
	// Português:
	//
	//  Audio tipo 'VDVI'
	KMimeAudioVDVI Mime = "audio/VDVI"

	// KMimeAudioVMRWB
	//
	// English:
	//
	//  Audio type 'VMR-WB'
	//
	// Português:
	//
	//  Audio tipo 'VMR-WB'
	KMimeAudioVMRWB Mime = "audio/VMR-WB"

	// KMimeAudioVnd3gppIufp
	//
	// English:
	//
	//  Audio type 'vnd.3gpp.iufp'
	//
	// Português:
	//
	//  Audio tipo 'vnd.3gpp.iufp'
	KMimeAudioVnd3gppIufp Mime = "audio/vnd.3gpp.iufp"

	// KMimeAudioVnd4SB
	//
	// English:
	//
	//  Audio type 'vnd.4SB'
	//
	// Português:
	//
	//  Audio tipo 'vnd.4SB'
	KMimeAudioVnd4SB Mime = "audio/vnd.4SB"

	// KMimeAudioVndAudiokoz
	//
	// English:
	//
	//  Audio type 'vnd.audiokoz'
	//
	// Português:
	//
	//  Audio tipo 'vnd.audiokoz'
	KMimeAudioVndAudiokoz Mime = "audio/vnd.audiokoz"

	// KMimeAudioVndCELP
	//
	// English:
	//
	//  Audio type 'vnd.CELP'
	//
	// Português:
	//
	//  Audio tipo 'vnd.CELP'
	KMimeAudioVndCELP Mime = "audio/vnd.CELP"

	// KMimeAudioVndCiscoNse
	//
	// English:
	//
	//  Audio type 'vnd.cisco.nse'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cisco.nse'
	KMimeAudioVndCiscoNse Mime = "audio/vnd.cisco.nse"

	// KMimeAudioVndCmlesRadioEvents
	//
	// English:
	//
	//  Audio type 'vnd.cmles.radio-events'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cmles.radio-events'
	KMimeAudioVndCmlesRadioEvents Mime = "audio/vnd.cmles.radio-events"

	// KMimeAudioVndCnsAnp1
	//
	// English:
	//
	//  Audio type 'vnd.cns.anp1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cns.anp1'
	KMimeAudioVndCnsAnp1 Mime = "audio/vnd.cns.anp1"

	// KMimeAudioVndCnsInf1
	//
	// English:
	//
	//  Audio type 'vnd.cns.inf1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.cns.inf1'
	KMimeAudioVndCnsInf1 Mime = "audio/vnd.cns.inf1"

	// KMimeAudioVndDeceAudio
	//
	// English:
	//
	//  Audio type 'vnd.dece.audio'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dece.audio'
	KMimeAudioVndDeceAudio Mime = "audio/vnd.dece.audio"

	// KMimeAudioVndDigitalWinds
	//
	// English:
	//
	//  Audio type 'vnd.digital-winds'
	//
	// Português:
	//
	//  Audio tipo 'vnd.digital-winds'
	KMimeAudioVndDigitalWinds Mime = "audio/vnd.digital-winds"

	// KMimeAudioVndDlnaAdts
	//
	// English:
	//
	//  Audio type 'vnd.dlna.adts'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dlna.adts'
	KMimeAudioVndDlnaAdts Mime = "audio/vnd.dlna.adts"

	// KMimeAudioVndDolbyHeaac1
	//
	// English:
	//
	//  Audio type 'vnd.dolby.heaac.1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.heaac.1'
	KMimeAudioVndDolbyHeaac1 Mime = "audio/vnd.dolby.heaac.1"

	// KMimeAudioVndDolbyHeaac2
	//
	// English:
	//
	//  Audio type 'vnd.dolby.heaac.2'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.heaac.2'
	KMimeAudioVndDolbyHeaac2 Mime = "audio/vnd.dolby.heaac.2"

	// KMimeAudioVndDolbyMlp
	//
	// English:
	//
	//  Audio type 'vnd.dolby.mlp'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.mlp'
	KMimeAudioVndDolbyMlp Mime = "audio/vnd.dolby.mlp"

	// KMimeAudioVndDolbyMps
	//
	// English:
	//
	//  Audio type 'vnd.dolby.mps'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.mps'
	KMimeAudioVndDolbyMps Mime = "audio/vnd.dolby.mps"

	// KMimeAudioVndDolbyPl2
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pl2'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pl2'
	KMimeAudioVndDolbyPl2 Mime = "audio/vnd.dolby.pl2"

	// KMimeAudioVndDolbyPl2x
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pl2x'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pl2x'
	KMimeAudioVndDolbyPl2x Mime = "audio/vnd.dolby.pl2x"

	// KMimeAudioVndDolbyPl2z
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pl2z'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pl2z'
	KMimeAudioVndDolbyPl2z Mime = "audio/vnd.dolby.pl2z"

	// KMimeAudioVndDolbyPulse1
	//
	// English:
	//
	//  Audio type 'vnd.dolby.pulse.1'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dolby.pulse.1'
	KMimeAudioVndDolbyPulse1 Mime = "audio/vnd.dolby.pulse.1"

	// KMimeAudioVndDra
	//
	// English:
	//
	//  Audio type 'vnd.dra'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dra'
	KMimeAudioVndDra Mime = "audio/vnd.dra"

	// KMimeAudioVndDts
	//
	// English:
	//
	//  Audio type 'vnd.dts'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dts'
	KMimeAudioVndDts Mime = "audio/vnd.dts"

	// KMimeAudioVndDtsHd
	//
	// English:
	//
	//  Audio type 'vnd.dts.hd'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dts.hd'
	KMimeAudioVndDtsHd Mime = "audio/vnd.dts.hd"

	// KMimeAudioVndDtsUhd
	//
	// English:
	//
	//  Audio type 'vnd.dts.uhd'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dts.uhd'
	KMimeAudioVndDtsUhd Mime = "audio/vnd.dts.uhd"

	// KMimeAudioVndDvbFile
	//
	// English:
	//
	//  Audio type 'vnd.dvb.file'
	//
	// Português:
	//
	//  Audio tipo 'vnd.dvb.file'
	KMimeAudioVndDvbFile Mime = "audio/vnd.dvb.file"

	// KMimeAudioVndEveradPlj
	//
	// English:
	//
	//  Audio type 'vnd.everad.plj'
	//
	// Português:
	//
	//  Audio tipo 'vnd.everad.plj'
	KMimeAudioVndEveradPlj Mime = "audio/vnd.everad.plj"

	// KMimeAudioVndHnsAudio
	//
	// English:
	//
	//  Audio type 'vnd.hns.audio'
	//
	// Português:
	//
	//  Audio tipo 'vnd.hns.audio'
	KMimeAudioVndHnsAudio Mime = "audio/vnd.hns.audio"

	// KMimeAudioVndLucentVoice
	//
	// English:
	//
	//  Audio type 'vnd.lucent.voice'
	//
	// Português:
	//
	//  Audio tipo 'vnd.lucent.voice'
	KMimeAudioVndLucentVoice Mime = "audio/vnd.lucent.voice"

	// KMimeAudioVndMsPlayreadyMediaPya
	//
	// English:
	//
	//  Audio type 'vnd.ms-playready.media.pya'
	//
	// Português:
	//
	//  Audio tipo 'vnd.ms-playready.media.pya'
	KMimeAudioVndMsPlayreadyMediaPya Mime = "audio/vnd.ms-playready.media.pya"

	// KMimeAudioVndNokiaMobileXmf
	//
	// English:
	//
	//  Audio type 'vnd.nokia.mobile-xmf'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nokia.mobile-xmf'
	KMimeAudioVndNokiaMobileXmf Mime = "audio/vnd.nokia.mobile-xmf"

	// KMimeAudioVndNortelVbk
	//
	// English:
	//
	//  Audio type 'vnd.nortel.vbk'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nortel.vbk'
	KMimeAudioVndNortelVbk Mime = "audio/vnd.nortel.vbk"

	// KMimeAudioVndNueraEcelp4800
	//
	// English:
	//
	//  Audio type 'vnd.nuera.ecelp4800'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nuera.ecelp4800'
	KMimeAudioVndNueraEcelp4800 Mime = "audio/vnd.nuera.ecelp4800"

	// KMimeAudioVndNueraEcelp7470
	//
	// English:
	//
	//  Audio type 'vnd.nuera.ecelp7470'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nuera.ecelp7470'
	KMimeAudioVndNueraEcelp7470 Mime = "audio/vnd.nuera.ecelp7470"

	// KMimeAudioVndNueraEcelp9600
	//
	// English:
	//
	//  Audio type 'vnd.nuera.ecelp9600'
	//
	// Português:
	//
	//  Audio tipo 'vnd.nuera.ecelp9600'
	KMimeAudioVndNueraEcelp9600 Mime = "audio/vnd.nuera.ecelp9600"

	// KMimeAudioVndOctelSbc
	//
	// English:
	//
	//  Audio type 'vnd.octel.sbc'
	//
	// Português:
	//
	//  Audio tipo 'vnd.octel.sbc'
	KMimeAudioVndOctelSbc Mime = "audio/vnd.octel.sbc"

	// KMimeAudioVndPresonusMultitrack
	//
	// English:
	//
	//  Audio type 'vnd.presonus.multitrack'
	//
	// Português:
	//
	//  Audio tipo 'vnd.presonus.multitrack'
	KMimeAudioVndPresonusMultitrack Mime = "audio/vnd.presonus.multitrack"

	// KMimeAudioVndRhetorex32kadpcm
	//
	// English:
	//
	//  Audio type 'vnd.rhetorex.32kadpcm'
	//
	// Português:
	//
	//  Audio tipo 'vnd.rhetorex.32kadpcm'
	KMimeAudioVndRhetorex32kadpcm Mime = "audio/vnd.rhetorex.32kadpcm"

	// KMimeAudioVndRip
	//
	// English:
	//
	//  Audio type 'vnd.rip'
	//
	// Português:
	//
	//  Audio tipo 'vnd.rip'
	KMimeAudioVndRip Mime = "audio/vnd.rip"

	// KMimeAudioVndSealedmediaSoftsealMpeg
	//
	// English:
	//
	//  Audio type 'vnd.sealedmedia.softseal.mpeg'
	//
	// Português:
	//
	//  Audio tipo 'vnd.sealedmedia.softseal.mpeg'
	KMimeAudioVndSealedmediaSoftsealMpeg Mime = "audio/vnd.sealedmedia.softseal.mpeg"

	// KMimeAudioVndVmxCvsd
	//
	// English:
	//
	//  Audio type 'vnd.vmx.cvsd'
	//
	// Português:
	//
	//  Audio tipo 'vnd.vmx.cvsd'
	KMimeAudioVndVmxCvsd Mime = "audio/vnd.vmx.cvsd"

	// KMimeAudioVorbis
	//
	// English:
	//
	//  Audio type 'vorbis'
	//
	// Português:
	//
	//  Audio tipo 'vorbis'
	KMimeAudioVorbis Mime = "audio/vorbis"

	// KMimeAudioVorbisConfig
	//
	// English:
	//
	//  Audio type 'vorbis-config'
	//
	// Português:
	//
	//  Audio tipo 'vorbis-config'
	KMimeAudioVorbisConfig Mime = "audio/vorbis-config"
)
const (
	// KMimeFontCollection
	//
	// English:
	//
	//  Font type 'collection'
	//
	// Português:
	//
	//  Fonte tipo 'collection'
	KMimeFontCollection Mime = "font/collection"

	// KMimeFontOtf
	//
	// English:
	//
	//  Font type 'otf'
	//
	// Português:
	//
	//  Fonte tipo 'otf'
	KMimeFontOtf Mime = "font/otf"

	// KMimeFontSfnt
	//
	// English:
	//
	//  Font type 'sfnt'
	//
	// Português:
	//
	//  Fonte tipo 'sfnt'
	KMimeFontSfnt Mime = "font/sfnt"

	// KMimeFontTtf
	//
	// English:
	//
	//  Font type 'ttf'
	//
	// Português:
	//
	//  Fonte tipo 'ttf'
	KMimeFontTtf Mime = "font/ttf"

	// KMimeFontWoff
	//
	// English:
	//
	//  Font type 'woff'
	//
	// Português:
	//
	//  Fonte tipo 'woff'
	KMimeFontWoff Mime = "font/woff"

	// KMimeFontWoff2
	//
	// English:
	//
	//  Font type 'woff2'
	//
	// Português:
	//
	//  Fonte tipo 'woff2'
	KMimeFontWoff2 Mime = "font/woff2"
)
const (
	// KMimeImageAces
	//
	// English:
	//
	//  Imagem type 'aces'
	//
	// Português:
	//
	//  Imagem tipo 'aces'
	KMimeImageAces Mime = "image/aces"

	// KMimeImageAvci
	//
	// English:
	//
	//  Imagem type 'avci'
	//
	// Português:
	//
	//  Imagem tipo 'avci'
	KMimeImageAvci Mime = "image/avci"

	// KMimeImageAvcs
	//
	// English:
	//
	//  Imagem type 'avcs'
	//
	// Português:
	//
	//  Imagem tipo 'avcs'
	KMimeImageAvcs Mime = "image/avcs"

	// KMimeImageAvif
	//
	// English:
	//
	//  Imagem type 'avif'
	//
	// Português:
	//
	//  Imagem tipo 'avif'
	KMimeImageAvif Mime = "image/avif"

	// KMimeImageBmp
	//
	// English:
	//
	//  Imagem type 'bmp'
	//
	// Português:
	//
	//  Imagem tipo 'bmp'
	KMimeImageBmp Mime = "image/bmp"

	// KMimeImageCgm
	//
	// English:
	//
	//  Imagem type 'cgm'
	//
	// Português:
	//
	//  Imagem tipo 'cgm'
	KMimeImageCgm Mime = "image/cgm"

	// KMimeImageDicomRle
	//
	// English:
	//
	//  Imagem type 'dicom-rle'
	//
	// Português:
	//
	//  Imagem tipo 'dicom-rle'
	KMimeImageDicomRle Mime = "image/dicom-rle"

	// KMimeImageEmf
	//
	// English:
	//
	//  Imagem type 'emf'
	//
	// Português:
	//
	//  Imagem tipo 'emf'
	KMimeImageEmf Mime = "image/emf"

	// KMimeImageExample
	//
	// English:
	//
	//  Imagem type 'example'
	//
	// Português:
	//
	//  Imagem tipo 'example'
	KMimeImageExample Mime = "image/example"

	// KMimeImageFits
	//
	// English:
	//
	//  Imagem type 'fits'
	//
	// Português:
	//
	//  Imagem tipo 'fits'
	KMimeImageFits Mime = "image/fits"

	// KMimeImageG3fax
	//
	// English:
	//
	//  Imagem type 'g3fax'
	//
	// Português:
	//
	//  Imagem tipo 'g3fax'
	KMimeImageG3fax Mime = "image/g3fax"

	// KMimeImageGif
	//
	// English:
	//
	//  Imagem type 'gif'
	//
	// Português:
	//
	//  Imagem tipo 'gif'
	KMimeImageGif Mime = "[RFC2045][RFC2046]"

	// KMimeImageHeic
	//
	// English:
	//
	//  Imagem type 'heic'
	//
	// Português:
	//
	//  Imagem tipo 'heic'
	KMimeImageHeic Mime = "image/heic"

	// KMimeImageHeicSequence
	//
	// English:
	//
	//  Imagem type 'heic-sequence'
	//
	// Português:
	//
	//  Imagem tipo 'heic-sequence'
	KMimeImageHeicSequence Mime = "image/heic-sequence"

	// KMimeImageHeif
	//
	// English:
	//
	//  Imagem type 'heif'
	//
	// Português:
	//
	//  Imagem tipo 'heif'
	KMimeImageHeif Mime = "image/heif"

	// KMimeImageHeifSequence
	//
	// English:
	//
	//  Imagem type 'heif-sequence'
	//
	// Português:
	//
	//  Imagem tipo 'heif-sequence'
	KMimeImageHeifSequence Mime = "image/heif-sequence"

	// KMimeImageHej2k
	//
	// English:
	//
	//  Imagem type 'hej2k'
	//
	// Português:
	//
	//  Imagem tipo 'hej2k'
	KMimeImageHej2k Mime = "image/hej2k"

	// KMimeImageHsj2
	//
	// English:
	//
	//  Imagem type 'hsj2'
	//
	// Português:
	//
	//  Imagem tipo 'hsj2'
	KMimeImageHsj2 Mime = "image/hsj2"

	// KMimeImageIef
	//
	// English:
	//
	//  Imagem type 'ief'
	//
	// Português:
	//
	//  Imagem tipo 'ief'
	KMimeImageIef Mime = "[RFC1314]"

	// KMimeImageJls
	//
	// English:
	//
	//  Imagem type 'jls'
	//
	// Português:
	//
	//  Imagem tipo 'jls'
	KMimeImageJls Mime = "image/jls"

	// KMimeImageJp2
	//
	// English:
	//
	//  Imagem type 'jp2'
	//
	// Português:
	//
	//  Imagem tipo 'jp2'
	KMimeImageJp2 Mime = "image/jp2"

	// KMimeImageJpeg
	//
	// English:
	//
	//  Imagem type 'jpeg'
	//
	// Português:
	//
	//  Imagem tipo 'jpeg'
	KMimeImageJpeg Mime = "[RFC2045][RFC2046]"

	// KMimeImageJph
	//
	// English:
	//
	//  Imagem type 'jph'
	//
	// Português:
	//
	//  Imagem tipo 'jph'
	KMimeImageJph Mime = "image/jph"

	// KMimeImageJphc
	//
	// English:
	//
	//  Imagem type 'jphc'
	//
	// Português:
	//
	//  Imagem tipo 'jphc'
	KMimeImageJphc Mime = "image/jphc"

	// KMimeImageJpm
	//
	// English:
	//
	//  Imagem type 'jpm'
	//
	// Português:
	//
	//  Imagem tipo 'jpm'
	KMimeImageJpm Mime = "image/jpm"

	// KMimeImageJpx
	//
	// English:
	//
	//  Imagem type 'jpx'
	//
	// Português:
	//
	//  Imagem tipo 'jpx'
	KMimeImageJpx Mime = "image/jpx"

	// KMimeImageJxr
	//
	// English:
	//
	//  Imagem type 'jxr'
	//
	// Português:
	//
	//  Imagem tipo 'jxr'
	KMimeImageJxr Mime = "image/jxr"

	// KMimeImageJxrA
	//
	// English:
	//
	//  Imagem type 'jxrA'
	//
	// Português:
	//
	//  Imagem tipo 'jxrA'
	KMimeImageJxrA Mime = "image/jxrA"

	// KMimeImageJxrS
	//
	// English:
	//
	//  Imagem type 'jxrS'
	//
	// Português:
	//
	//  Imagem tipo 'jxrS'
	KMimeImageJxrS Mime = "image/jxrS"

	// KMimeImageJxs
	//
	// English:
	//
	//  Imagem type 'jxs'
	//
	// Português:
	//
	//  Imagem tipo 'jxs'
	KMimeImageJxs Mime = "image/jxs"

	// KMimeImageJxsc
	//
	// English:
	//
	//  Imagem type 'jxsc'
	//
	// Português:
	//
	//  Imagem tipo 'jxsc'
	KMimeImageJxsc Mime = "image/jxsc"

	// KMimeImageJxsi
	//
	// English:
	//
	//  Imagem type 'jxsi'
	//
	// Português:
	//
	//  Imagem tipo 'jxsi'
	KMimeImageJxsi Mime = "image/jxsi"

	// KMimeImageJxss
	//
	// English:
	//
	//  Imagem type 'jxss'
	//
	// Português:
	//
	//  Imagem tipo 'jxss'
	KMimeImageJxss Mime = "image/jxss"

	// KMimeImageKtx
	//
	// English:
	//
	//  Imagem type 'ktx'
	//
	// Português:
	//
	//  Imagem tipo 'ktx'
	KMimeImageKtx Mime = "image/ktx"

	// KMimeImageKtx2
	//
	// English:
	//
	//  Imagem type 'ktx2'
	//
	// Português:
	//
	//  Imagem tipo 'ktx2'
	KMimeImageKtx2 Mime = "image/ktx2"

	// KMimeImageNaplps
	//
	// English:
	//
	//  Imagem type 'naplps'
	//
	// Português:
	//
	//  Imagem tipo 'naplps'
	KMimeImageNaplps Mime = "image/naplps"

	// KMimeImagePng
	//
	// English:
	//
	//  Imagem type 'png'
	//
	// Português:
	//
	//  Imagem tipo 'png'
	KMimeImagePng Mime = "image/png"

	// KMimeImagePrsBtif
	//
	// English:
	//
	//  Imagem type 'prs.btif'
	//
	// Português:
	//
	//  Imagem tipo 'prs.btif'
	KMimeImagePrsBtif Mime = "image/prs.btif"

	// KMimeImagePrsPti
	//
	// English:
	//
	//  Imagem type 'prs.pti'
	//
	// Português:
	//
	//  Imagem tipo 'prs.pti'
	KMimeImagePrsPti Mime = "image/prs.pti"

	// KMimeImagePwgRaster
	//
	// English:
	//
	//  Imagem type 'pwg-raster'
	//
	// Português:
	//
	//  Imagem tipo 'pwg-raster'
	KMimeImagePwgRaster Mime = "image/pwg-raster"

	// KMimeImageSvgXml
	//
	// English:
	//
	//  Imagem type 'svg+xml'
	//
	// Português:
	//
	//  Imagem tipo 'svg+xml'
	KMimeImageSvgXml Mime = "image/svg+xml"

	// KMimeImageT38
	//
	// English:
	//
	//  Imagem type 't38'
	//
	// Português:
	//
	//  Imagem tipo 't38'
	KMimeImageT38 Mime = "image/t38"

	// KMimeImageTiff
	//
	// English:
	//
	//  Imagem type 'tiff'
	//
	// Português:
	//
	//  Imagem tipo 'tiff'
	KMimeImageTiff Mime = "image/tiff"

	// KMimeImageTiffFx
	//
	// English:
	//
	//  Imagem type 'tiff-fx'
	//
	// Português:
	//
	//  Imagem tipo 'tiff-fx'
	KMimeImageTiffFx Mime = "image/tiff-fx"

	// KMimeImageVndAdobePhotoshop
	//
	// English:
	//
	//  Imagem type 'vnd.adobe.photoshop'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.adobe.photoshop'
	KMimeImageVndAdobePhotoshop Mime = "image/vnd.adobe.photoshop"

	// KMimeImageVndAirzipAcceleratorAzv
	//
	// English:
	//
	//  Imagem type 'vnd.airzip.accelerator.azv'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.airzip.accelerator.azv'
	KMimeImageVndAirzipAcceleratorAzv Mime = "image/vnd.airzip.accelerator.azv"

	// KMimeImageVndCnsInf2
	//
	// English:
	//
	//  Imagem type 'vnd.cns.inf2'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.cns.inf2'
	KMimeImageVndCnsInf2 Mime = "image/vnd.cns.inf2"

	// KMimeImageVndDeceGraphic
	//
	// English:
	//
	//  Imagem type 'vnd.dece.graphic'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dece.graphic'
	KMimeImageVndDeceGraphic Mime = "image/vnd.dece.graphic"

	// KMimeImageVndDjvu
	//
	// English:
	//
	//  Imagem type 'vnd.djvu'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.djvu'
	KMimeImageVndDjvu Mime = "image/vnd.djvu"

	// KMimeImageVndDwg
	//
	// English:
	//
	//  Imagem type 'vnd.dwg'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dwg'
	KMimeImageVndDwg Mime = "image/vnd.dwg"

	// KMimeImageVndDxf
	//
	// English:
	//
	//  Imagem type 'vnd.dxf'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dxf'
	KMimeImageVndDxf Mime = "image/vnd.dxf"

	// KMimeImageVndDvbSubtitle
	//
	// English:
	//
	//  Imagem type 'vnd.dvb.subtitle'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.dvb.subtitle'
	KMimeImageVndDvbSubtitle Mime = "image/vnd.dvb.subtitle"

	// KMimeImageVndFastbidsheet
	//
	// English:
	//
	//  Imagem type 'vnd.fastbidsheet'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fastbidsheet'
	KMimeImageVndFastbidsheet Mime = "image/vnd.fastbidsheet"

	// KMimeImageVndFpx
	//
	// English:
	//
	//  Imagem type 'vnd.fpx'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fpx'
	KMimeImageVndFpx Mime = "image/vnd.fpx"

	// KMimeImageVndFst
	//
	// English:
	//
	//  Imagem type 'vnd.fst'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fst'
	KMimeImageVndFst Mime = "image/vnd.fst"

	// KMimeImageVndFujixeroxEdmicsMmr
	//
	// English:
	//
	//  Imagem type 'vnd.fujixerox.edmics-mmr'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fujixerox.edmics-mmr'
	KMimeImageVndFujixeroxEdmicsMmr Mime = "image/vnd.fujixerox.edmics-mmr"

	// KMimeImageVndFujixeroxEdmicsRlc
	//
	// English:
	//
	//  Imagem type 'vnd.fujixerox.edmics-rlc'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.fujixerox.edmics-rlc'
	KMimeImageVndFujixeroxEdmicsRlc Mime = "image/vnd.fujixerox.edmics-rlc"

	// KMimeImageVndGlobalgraphicsPgb
	//
	// English:
	//
	//  Imagem type 'vnd.globalgraphics.pgb'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.globalgraphics.pgb'
	KMimeImageVndGlobalgraphicsPgb Mime = "image/vnd.globalgraphics.pgb"

	// KMimeImageVndMicrosoftIcon
	//
	// English:
	//
	//  Imagem type 'vnd.microsoft.icon'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.microsoft.icon'
	KMimeImageVndMicrosoftIcon Mime = "image/vnd.microsoft.icon"

	// KMimeImageVndMix
	//
	// English:
	//
	//  Imagem type 'vnd.mix'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.mix'
	KMimeImageVndMix Mime = "image/vnd.mix"

	// KMimeImageVndMsModi
	//
	// English:
	//
	//  Imagem type 'vnd.ms-modi'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.ms-modi'
	KMimeImageVndMsModi Mime = "image/vnd.ms-modi"

	// KMimeImageVndMozillaApng
	//
	// English:
	//
	//  Imagem type 'vnd.mozilla.apng'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.mozilla.apng'
	KMimeImageVndMozillaApng Mime = "image/vnd.mozilla.apng"

	// KMimeImageVndNetFpx
	//
	// English:
	//
	//  Imagem type 'vnd.net-fpx'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.net-fpx'
	KMimeImageVndNetFpx Mime = "image/vnd.net-fpx"

	// KMimeImageVndPcoB16
	//
	// English:
	//
	//  Imagem type 'vnd.pco.b16'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.pco.b16'
	KMimeImageVndPcoB16 Mime = "image/vnd.pco.b16"

	// KMimeImageVndRadiance
	//
	// English:
	//
	//  Imagem type 'vnd.radiance'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.radiance'
	KMimeImageVndRadiance Mime = "image/vnd.radiance"

	// KMimeImageVndSealedPng
	//
	// English:
	//
	//  Imagem type 'vnd.sealed.png'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.sealed.png'
	KMimeImageVndSealedPng Mime = "image/vnd.sealed.png"

	// KMimeImageVndSealedmediaSoftsealGif
	//
	// English:
	//
	//  Imagem type 'vnd.sealedmedia.softseal.gif'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.sealedmedia.softseal.gif'
	KMimeImageVndSealedmediaSoftsealGif Mime = "image/vnd.sealedmedia.softseal.gif"

	// KMimeImageVndSealedmediaSoftsealJpg
	//
	// English:
	//
	//  Imagem type 'vnd.sealedmedia.softseal.jpg'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.sealedmedia.softseal.jpg'
	KMimeImageVndSealedmediaSoftsealJpg Mime = "image/vnd.sealedmedia.softseal.jpg"

	// KMimeImageVndSvf
	//
	// English:
	//
	//  Imagem type 'vnd.svf'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.svf'
	KMimeImageVndSvf Mime = "image/vnd.svf"

	// KMimeImageVndTencentTap
	//
	// English:
	//
	//  Imagem type 'vnd.tencent.tap'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.tencent.tap'
	KMimeImageVndTencentTap Mime = "image/vnd.tencent.tap"

	// KMimeImageVndValveSourceTexture
	//
	// English:
	//
	//  Imagem type 'vnd.valve.source.texture'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.valve.source.texture'
	KMimeImageVndValveSourceTexture Mime = "image/vnd.valve.source.texture"

	// KMimeImageVndWapWbmp
	//
	// English:
	//
	//  Imagem type 'vnd.wap.wbmp'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.wap.wbmp'
	KMimeImageVndWapWbmp Mime = "image/vnd.wap.wbmp"

	// KMimeImageVndXiff
	//
	// English:
	//
	//  Imagem type 'vnd.xiff'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.xiff'
	KMimeImageVndXiff Mime = "image/vnd.xiff"

	// KMimeImageVndZbrushPcx
	//
	// English:
	//
	//  Imagem type 'vnd.zbrush.pcx'
	//
	// Português:
	//
	//  Imagem tipo 'vnd.zbrush.pcx'
	KMimeImageVndZbrushPcx Mime = "image/vnd.zbrush.pcx"

	// KMimeImageWmf
	//
	// English:
	//
	//  Imagem type 'wmf'
	//
	// Português:
	//
	//  Imagem tipo 'wmf'
	KMimeImageWmf Mime = "image/wmf"
)
const (
	// KMimeMessageCPIM
	//
	// English:
	//
	//  Message type 'CPIM'
	//
	// Português:
	//
	//  Mensagem tipo 'CPIM'
	KMimeMessageCPIM Mime = "message/CPIM"

	// KMimeMessageDeliveryStatus
	//
	// English:
	//
	//  Message type 'delivery-status'
	//
	// Português:
	//
	//  Mensagem tipo 'delivery-status'
	KMimeMessageDeliveryStatus Mime = "message/delivery-status"

	// KMimeMessageDispositionNotification
	//
	// English:
	//
	//  Message type 'disposition-notification'
	//
	// Português:
	//
	//  Mensagem tipo 'disposition-notification'
	KMimeMessageDispositionNotification Mime = "message/disposition-notification"

	// KMimeMessageExample
	//
	// English:
	//
	//  Message type 'example'
	//
	// Português:
	//
	//  Mensagem tipo 'example'
	KMimeMessageExample Mime = "message/example"

	// KMimeMessageExternalBody
	//
	// English:
	//
	//  Message type 'external-body'
	//
	// Português:
	//
	//  Mensagem tipo 'external-body'
	KMimeMessageExternalBody Mime = "[RFC2045][RFC2046]"

	// KMimeMessageFeedbackReport
	//
	// English:
	//
	//  Message type 'feedback-report'
	//
	// Português:
	//
	//  Mensagem tipo 'feedback-report'
	KMimeMessageFeedbackReport Mime = "message/feedback-report"

	// KMimeMessageGlobal
	//
	// English:
	//
	//  Message type 'global'
	//
	// Português:
	//
	//  Mensagem tipo 'global'
	KMimeMessageGlobal Mime = "message/global"

	// KMimeMessageGlobalDeliveryStatus
	//
	// English:
	//
	//  Message type 'global-delivery-status'
	//
	// Português:
	//
	//  Mensagem tipo 'global-delivery-status'
	KMimeMessageGlobalDeliveryStatus Mime = "message/global-delivery-status"

	// KMimeMessageGlobalDispositionNotification
	//
	// English:
	//
	//  Message type 'global-disposition-notification'
	//
	// Português:
	//
	//  Mensagem tipo 'global-disposition-notification'
	KMimeMessageGlobalDispositionNotification Mime = "message/global-disposition-notification"

	// KMimeMessageGlobalHeaders
	//
	// English:
	//
	//  Message type 'global-headers'
	//
	// Português:
	//
	//  Mensagem tipo 'global-headers'
	KMimeMessageGlobalHeaders Mime = "message/global-headers"

	// KMimeMessageHttp
	//
	// English:
	//
	//  Message type 'http'
	//
	// Português:
	//
	//  Mensagem tipo 'http'
	KMimeMessageHttp Mime = "message/http"

	// KMimeMessageImdnXml
	//
	// English:
	//
	//  Message type 'imdn+xml'
	//
	// Português:
	//
	//  Mensagem tipo 'imdn+xml'
	KMimeMessageImdnXml Mime = "message/imdn+xml"

	// KMimeMessagePartial
	//
	// English:
	//
	//  Message type 'partial'
	//
	// Português:
	//
	//  Mensagem tipo 'partial'
	KMimeMessagePartial Mime = "[RFC2045][RFC2046]"

	// KMimeMessageRfc822
	//
	// English:
	//
	//  Message type 'rfc822'
	//
	// Português:
	//
	//  Mensagem tipo 'rfc822'
	KMimeMessageRfc822 Mime = "[RFC2045][RFC2046]"

	// KMimeMessageSip
	//
	// English:
	//
	//  Message type 'sip'
	//
	// Português:
	//
	//  Mensagem tipo 'sip'
	KMimeMessageSip Mime = "message/sip"

	// KMimeMessageSipfrag
	//
	// English:
	//
	//  Message type 'sipfrag'
	//
	// Português:
	//
	//  Mensagem tipo 'sipfrag'
	KMimeMessageSipfrag Mime = "message/sipfrag"

	// KMimeMessageTrackingStatus
	//
	// English:
	//
	//  Message type 'tracking-status'
	//
	// Português:
	//
	//  Mensagem tipo 'tracking-status'
	KMimeMessageTrackingStatus Mime = "message/tracking-status"

	// KMimeMessageVndWfaWsc
	//
	// English:
	//
	//  Message type 'vnd.wfa.wsc'
	//
	// Português:
	//
	//  Mensagem tipo 'vnd.wfa.wsc'
	KMimeMessageVndWfaWsc Mime = "message/vnd.wfa.wsc"
)
const (
	// KMimeModel3mf
	//
	// English:
	//
	//  Model type '3mf'
	//
	// Português:
	//
	//  Modelo tipo '3mf'
	KMimeModel3mf Mime = "model/3mf"

	// KMimeModelE57
	//
	// English:
	//
	//  Model type 'e57'
	//
	// Português:
	//
	//  Modelo tipo 'e57'
	KMimeModelE57 Mime = "model/e57"

	// KMimeModelExample
	//
	// English:
	//
	//  Model type 'example'
	//
	// Português:
	//
	//  Modelo tipo 'example'
	KMimeModelExample Mime = "model/example"

	// KMimeModelGltfBinary
	//
	// English:
	//
	//  Model type 'gltf-binary'
	//
	// Português:
	//
	//  Modelo tipo 'gltf-binary'
	KMimeModelGltfBinary Mime = "model/gltf-binary"

	// KMimeModelGltfJson
	//
	// English:
	//
	//  Model type 'gltf+json'
	//
	// Português:
	//
	//  Modelo tipo 'gltf+json'
	KMimeModelGltfJson Mime = "model/gltf+json"

	// KMimeModelIges
	//
	// English:
	//
	//  Model type 'iges'
	//
	// Português:
	//
	//  Modelo tipo 'iges'
	KMimeModelIges Mime = "model/iges"

	// KMimeModelMesh
	//
	// English:
	//
	//  Model type 'mesh'
	//
	// Português:
	//
	//  Modelo tipo 'mesh'
	KMimeModelMesh Mime = "model/mesh"

	// KMimeModelMtl
	//
	// English:
	//
	//  Model type 'mtl'
	//
	// Português:
	//
	//  Modelo tipo 'mtl'
	KMimeModelMtl Mime = "model/mtl"

	// KMimeModelObj
	//
	// English:
	//
	//  Model type 'obj'
	//
	// Português:
	//
	//  Modelo tipo 'obj'
	KMimeModelObj Mime = "model/obj"

	// KMimeModelPrc
	//
	// English:
	//
	//  Model type 'prc'
	//
	// Português:
	//
	//  Modelo tipo 'prc'
	KMimeModelPrc Mime = "model/prc"

	// KMimeModelStep
	//
	// English:
	//
	//  Model type 'step'
	//
	// Português:
	//
	//  Modelo tipo 'step'
	KMimeModelStep Mime = "model/step"

	// KMimeModelStepXml
	//
	// English:
	//
	//  Model type 'step+xml'
	//
	// Português:
	//
	//  Modelo tipo 'step+xml'
	KMimeModelStepXml Mime = "model/step+xml"

	// KMimeModelStepZip
	//
	// English:
	//
	//  Model type 'step+zip'
	//
	// Português:
	//
	//  Modelo tipo 'step+zip'
	KMimeModelStepZip Mime = "model/step+zip"

	// KMimeModelStepXmlZip
	//
	// English:
	//
	//  Model type 'step-xml+zip'
	//
	// Português:
	//
	//  Modelo tipo 'step-xml+zip'
	KMimeModelStepXmlZip Mime = "model/step-xml+zip"

	// KMimeModelStl
	//
	// English:
	//
	//  Model type 'stl'
	//
	// Português:
	//
	//  Modelo tipo 'stl'
	KMimeModelStl Mime = "model/stl"

	// KMimeModelU3d
	//
	// English:
	//
	//  Model type 'u3d'
	//
	// Português:
	//
	//  Modelo tipo 'u3d'
	KMimeModelU3d Mime = "model/u3d"

	// KMimeModelVndColladaXml
	//
	// English:
	//
	//  Model type 'vnd.collada+xml'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.collada+xml'
	KMimeModelVndColladaXml Mime = "model/vnd.collada+xml"

	// KMimeModelVndDwf
	//
	// English:
	//
	//  Model type 'vnd.dwf'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.dwf'
	KMimeModelVndDwf Mime = "model/vnd.dwf"

	// KMimeModelVndFlatland3dml
	//
	// English:
	//
	//  Model type 'vnd.flatland.3dml'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.flatland.3dml'
	KMimeModelVndFlatland3dml Mime = "model/vnd.flatland.3dml"

	// KMimeModelVndGdl
	//
	// English:
	//
	//  Model type 'vnd.gdl'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.gdl'
	KMimeModelVndGdl Mime = "model/vnd.gdl"

	// KMimeModelVndGsGdl
	//
	// English:
	//
	//  Model type 'vnd.gs-gdl'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.gs-gdl'
	KMimeModelVndGsGdl Mime = "model/vnd.gs-gdl"

	// KMimeModelVndGtw
	//
	// English:
	//
	//  Model type 'vnd.gtw'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.gtw'
	KMimeModelVndGtw Mime = "model/vnd.gtw"

	// KMimeModelVndMomlXml
	//
	// English:
	//
	//  Model type 'vnd.moml+xml'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.moml+xml'
	KMimeModelVndMomlXml Mime = "model/vnd.moml+xml"

	// KMimeModelVndMts
	//
	// English:
	//
	//  Model type 'vnd.mts'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.mts'
	KMimeModelVndMts Mime = "model/vnd.mts"

	// KMimeModelVndOpengex
	//
	// English:
	//
	//  Model type 'vnd.opengex'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.opengex'
	KMimeModelVndOpengex Mime = "model/vnd.opengex"

	// KMimeModelVndParasolidTransmitBinary
	//
	// English:
	//
	//  Model type 'vnd.parasolid.transmit.binary'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.parasolid.transmit.binary'
	KMimeModelVndParasolidTransmitBinary Mime = "model/vnd.parasolid.transmit.binary"

	// KMimeModelVndParasolidTransmitText
	//
	// English:
	//
	//  Model type 'vnd.parasolid.transmit.text'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.parasolid.transmit.text'
	KMimeModelVndParasolidTransmitText Mime = "model/vnd.parasolid.transmit.text"

	// KMimeModelVndPythaPyox
	//
	// English:
	//
	//  Model type 'vnd.pytha.pyox'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.pytha.pyox'
	KMimeModelVndPythaPyox Mime = "model/vnd.pytha.pyox"

	// KMimeModelVndRosetteAnnotatedDataModel
	//
	// English:
	//
	//  Model type 'vnd.rosette.annotated-data-model'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.rosette.annotated-data-model'
	KMimeModelVndRosetteAnnotatedDataModel Mime = "model/vnd.rosette.annotated-data-model"

	// KMimeModelVndSapVds
	//
	// English:
	//
	//  Model type 'vnd.sap.vds'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.sap.vds'
	KMimeModelVndSapVds Mime = "model/vnd.sap.vds"

	// KMimeModelVndUsdzZip
	//
	// English:
	//
	//  Model type 'vnd.usdz+zip'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.usdz+zip'
	KMimeModelVndUsdzZip Mime = "model/vnd.usdz+zip"

	// KMimeModelVndValveSourceCompiledMap
	//
	// English:
	//
	//  Model type 'vnd.valve.source.compiled-map'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.valve.source.compiled-map'
	KMimeModelVndValveSourceCompiledMap Mime = "model/vnd.valve.source.compiled-map"

	// KMimeModelVndVtu
	//
	// English:
	//
	//  Model type 'vnd.vtu'
	//
	// Português:
	//
	//  Modelo tipo 'vnd.vtu'
	KMimeModelVndVtu Mime = "model/vnd.vtu"

	// KMimeModelVrml
	//
	// English:
	//
	//  Model type 'vrml'
	//
	// Português:
	//
	//  Modelo tipo 'vrml'
	KMimeModelVrml Mime = "[RFC2077]"

	// KMimeModelX3dVrml
	//
	// English:
	//
	//  Model type 'x3d-vrml'
	//
	// Português:
	//
	//  Modelo tipo 'x3d-vrml'
	KMimeModelX3dVrml Mime = "model/x3d-vrml"

	// KMimeModelX3dFastinfoset
	//
	// English:
	//
	//  Model type 'x3d+fastinfoset'
	//
	// Português:
	//
	//  Modelo tipo 'x3d+fastinfoset'
	KMimeModelX3dFastinfoset Mime = "model/x3d+fastinfoset"

	// KMimeModelX3dXml
	//
	// English:
	//
	//  Model type 'x3d+xml'
	//
	// Português:
	//
	//  Modelo tipo 'x3d+xml'
	KMimeModelX3dXml Mime = "model/x3d+xml"
)
const (
	// KMimeMultipartAlternative
	//
	// English:
	//
	//  Multipart type 'alternative'
	//
	// Português:
	//
	//  Multiparte tipo 'alternative'
	KMimeMultipartAlternative Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartAppledouble
	//
	// English:
	//
	//  Multipart type 'appledouble'
	//
	// Português:
	//
	//  Multiparte tipo 'appledouble'
	KMimeMultipartAppledouble Mime = "multipart/appledouble"

	// KMimeMultipartByteranges
	//
	// English:
	//
	//  Multipart type 'byteranges'
	//
	// Português:
	//
	//  Multiparte tipo 'byteranges'
	KMimeMultipartByteranges Mime = "multipart/byteranges"

	// KMimeMultipartDigest
	//
	// English:
	//
	//  Multipart type 'digest'
	//
	// Português:
	//
	//  Multiparte tipo 'digest'
	KMimeMultipartDigest Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartEncrypted
	//
	// English:
	//
	//  Multipart type 'encrypted'
	//
	// Português:
	//
	//  Multiparte tipo 'encrypted'
	KMimeMultipartEncrypted Mime = "multipart/encrypted"

	// KMimeMultipartExample
	//
	// English:
	//
	//  Multipart type 'example'
	//
	// Português:
	//
	//  Multiparte tipo 'example'
	KMimeMultipartExample Mime = "multipart/example"

	// KMimeMultipartFormData
	//
	// English:
	//
	//  Multipart type 'form-data'
	//
	// Português:
	//
	//  Multiparte tipo 'form-data'
	KMimeMultipartFormData Mime = "multipart/form-data"

	// KMimeMultipartHeaderSet
	//
	// English:
	//
	//  Multipart type 'header-set'
	//
	// Português:
	//
	//  Multiparte tipo 'header-set'
	KMimeMultipartHeaderSet Mime = "multipart/header-set"

	// KMimeMultipartMixed
	//
	// English:
	//
	//  Multipart type 'mixed'
	//
	// Português:
	//
	//  Multiparte tipo 'mixed'
	KMimeMultipartMixed Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartMultilingual
	//
	// English:
	//
	//  Multipart type 'multilingual'
	//
	// Português:
	//
	//  Multiparte tipo 'multilingual'
	KMimeMultipartMultilingual Mime = "multipart/multilingual"

	// KMimeMultipartParallel
	//
	// English:
	//
	//  Multipart type 'parallel'
	//
	// Português:
	//
	//  Multiparte tipo 'parallel'
	KMimeMultipartParallel Mime = "[RFC2046][RFC2045]"

	// KMimeMultipartRelated
	//
	// English:
	//
	//  Multipart type 'related'
	//
	// Português:
	//
	//  Multiparte tipo 'related'
	KMimeMultipartRelated Mime = "multipart/related"

	// KMimeMultipartReport
	//
	// English:
	//
	//  Multipart type 'report'
	//
	// Português:
	//
	//  Multiparte tipo 'report'
	KMimeMultipartReport Mime = "multipart/report"

	// KMimeMultipartSigned
	//
	// English:
	//
	//  Multipart type 'signed'
	//
	// Português:
	//
	//  Multiparte tipo 'signed'
	KMimeMultipartSigned Mime = "multipart/signed"

	// KMimeMultipartVndBintMedPlus
	//
	// English:
	//
	//  Multipart type 'vnd.bint.med-plus'
	//
	// Português:
	//
	//  Multiparte tipo 'vnd.bint.med-plus'
	KMimeMultipartVndBintMedPlus Mime = "multipart/vnd.bint.med-plus"

	// KMimeMultipartVoiceMessage
	//
	// English:
	//
	//  Multipart type 'voice-message'
	//
	// Português:
	//
	//  Multiparte tipo 'voice-message'
	KMimeMultipartVoiceMessage Mime = "multipart/voice-message"

	// KMimeMultipartXMixedReplace
	//
	// English:
	//
	//  Multipart type 'x-mixed-replace'
	//
	// Português:
	//
	//  Multiparte tipo 'x-mixed-replace'
	KMimeMultipartXMixedReplace Mime = "multipart/x-mixed-replace"
)
const (
	// KMimeText1dInterleavedParityfec
	//
	// English:
	//
	//  Text type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Texto tipo '1d-interleaved-parityfec'
	KMimeText1dInterleavedParityfec Mime = "text/1d-interleaved-parityfec"

	// KMimeTextCacheManifest
	//
	// English:
	//
	//  Text type 'cache-manifest'
	//
	// Português:
	//
	//  Texto tipo 'cache-manifest'
	KMimeTextCacheManifest Mime = "text/cache-manifest"

	// KMimeTextCalendar
	//
	// English:
	//
	//  Text type 'calendar'
	//
	// Português:
	//
	//  Texto tipo 'calendar'
	KMimeTextCalendar Mime = "text/calendar"

	// KMimeTextCql
	//
	// English:
	//
	//  Text type 'cql'
	//
	// Português:
	//
	//  Texto tipo 'cql'
	KMimeTextCql Mime = "text/cql"

	// KMimeTextCqlExpression
	//
	// English:
	//
	//  Text type 'cql-expression'
	//
	// Português:
	//
	//  Texto tipo 'cql-expression'
	KMimeTextCqlExpression Mime = "text/cql-expression"

	// KMimeTextCqlIdentifier
	//
	// English:
	//
	//  Text type 'cql-identifier'
	//
	// Português:
	//
	//  Texto tipo 'cql-identifier'
	KMimeTextCqlIdentifier Mime = "text/cql-identifier"

	// KMimeTextCss
	//
	// English:
	//
	//  Text type 'css'
	//
	// Português:
	//
	//  Texto tipo 'css'
	KMimeTextCss Mime = "text/css"

	// KMimeTextCsv
	//
	// English:
	//
	//  Text type 'csv'
	//
	// Português:
	//
	//  Texto tipo 'csv'
	KMimeTextCsv Mime = "text/csv"

	// KMimeTextCsvSchema
	//
	// English:
	//
	//  Text type 'csv-schema'
	//
	// Português:
	//
	//  Texto tipo 'csv-schema'
	KMimeTextCsvSchema Mime = "text/csv-schema"

	// KMimeTextDns
	//
	// English:
	//
	//  Text type 'dns'
	//
	// Português:
	//
	//  Texto tipo 'dns'
	KMimeTextDns Mime = "text/dns"

	// KMimeTextEncaprtp
	//
	// English:
	//
	//  Text type 'encaprtp'
	//
	// Português:
	//
	//  Texto tipo 'encaprtp'
	KMimeTextEncaprtp Mime = "text/encaprtp"

	// KMimeTextEnriched
	//
	// English:
	//
	//  Text type 'enriched'
	//
	// Português:
	//
	//  Texto tipo 'enriched'
	KMimeTextEnriched Mime = "[RFC1896]"

	// KMimeTextExample
	//
	// English:
	//
	//  Text type 'example'
	//
	// Português:
	//
	//  Texto tipo 'example'
	KMimeTextExample Mime = "text/example"

	// KMimeTextFhirpath
	//
	// English:
	//
	//  Text type 'fhirpath'
	//
	// Português:
	//
	//  Texto tipo 'fhirpath'
	KMimeTextFhirpath Mime = "text/fhirpath"

	// KMimeTextFlexfec
	//
	// English:
	//
	//  Text type 'flexfec'
	//
	// Português:
	//
	//  Texto tipo 'flexfec'
	KMimeTextFlexfec Mime = "text/flexfec"

	// KMimeTextFwdred
	//
	// English:
	//
	//  Text type 'fwdred'
	//
	// Português:
	//
	//  Texto tipo 'fwdred'
	KMimeTextFwdred Mime = "text/fwdred"

	// KMimeTextGff3
	//
	// English:
	//
	//  Text type 'gff3'
	//
	// Português:
	//
	//  Texto tipo 'gff3'
	KMimeTextGff3 Mime = "text/gff3"

	// KMimeTextGrammarRefList
	//
	// English:
	//
	//  Text type 'grammar-ref-list'
	//
	// Português:
	//
	//  Texto tipo 'grammar-ref-list'
	KMimeTextGrammarRefList Mime = "text/grammar-ref-list"

	// KMimeTextHtml
	//
	// English:
	//
	//  Text type 'html'
	//
	// Português:
	//
	//  Texto tipo 'html'
	KMimeTextHtml Mime = "text/html"

	// KMimeTextJavascript
	//
	// English:
	//
	//  Text type 'javascript'
	//
	// Português:
	//
	//  Texto tipo 'javascript'
	KMimeTextJavascript Mime = "text/javascript"

	// KMimeTextJcrCnd
	//
	// English:
	//
	//  Text type 'jcr-cnd'
	//
	// Português:
	//
	//  Texto tipo 'jcr-cnd'
	KMimeTextJcrCnd Mime = "text/jcr-cnd"

	// KMimeTextMarkdown
	//
	// English:
	//
	//  Text type 'markdown'
	//
	// Português:
	//
	//  Texto tipo 'markdown'
	KMimeTextMarkdown Mime = "text/markdown"

	// KMimeTextMizar
	//
	// English:
	//
	//  Text type 'mizar'
	//
	// Português:
	//
	//  Texto tipo 'mizar'
	KMimeTextMizar Mime = "text/mizar"

	// KMimeTextN3
	//
	// English:
	//
	//  Text type 'n3'
	//
	// Português:
	//
	//  Texto tipo 'n3'
	KMimeTextN3 Mime = "text/n3"

	// KMimeTextParameters
	//
	// English:
	//
	//  Text type 'parameters'
	//
	// Português:
	//
	//  Texto tipo 'parameters'
	KMimeTextParameters Mime = "text/parameters"

	// KMimeTextParityfec
	//
	// English:
	//
	//  Text type 'parityfec'
	//
	// Português:
	//
	//  Texto tipo 'parityfec'
	KMimeTextParityfec Mime = "text/parityfec"

	// KMimeTextPlain
	//
	// English:
	//
	//  Text type 'plain'
	//
	// Português:
	//
	//  Texto tipo 'plain'
	KMimeTextPlain Mime = "[RFC2046][RFC3676][RFC5147]"

	// KMimeTextProvenanceNotation
	//
	// English:
	//
	//  Text type 'provenance-notation'
	//
	// Português:
	//
	//  Texto tipo 'provenance-notation'
	KMimeTextProvenanceNotation Mime = "text/provenance-notation"

	// KMimeTextPrsFallensteinRst
	//
	// English:
	//
	//  Text type 'prs.fallenstein.rst'
	//
	// Português:
	//
	//  Texto tipo 'prs.fallenstein.rst'
	KMimeTextPrsFallensteinRst Mime = "text/prs.fallenstein.rst"

	// KMimeTextPrsLinesTag
	//
	// English:
	//
	//  Text type 'prs.lines.tag'
	//
	// Português:
	//
	//  Texto tipo 'prs.lines.tag'
	KMimeTextPrsLinesTag Mime = "text/prs.lines.tag"

	// KMimeTextPrsPropLogic
	//
	// English:
	//
	//  Text type 'prs.prop.logic'
	//
	// Português:
	//
	//  Texto tipo 'prs.prop.logic'
	KMimeTextPrsPropLogic Mime = "text/prs.prop.logic"

	// KMimeTextRaptorfec
	//
	// English:
	//
	//  Text type 'raptorfec'
	//
	// Português:
	//
	//  Texto tipo 'raptorfec'
	KMimeTextRaptorfec Mime = "text/raptorfec"

	// KMimeTextRED
	//
	// English:
	//
	//  Text type 'RED'
	//
	// Português:
	//
	//  Texto tipo 'RED'
	KMimeTextRED Mime = "text/RED"

	// KMimeTextRfc822Headers
	//
	// English:
	//
	//  Text type 'rfc822-headers'
	//
	// Português:
	//
	//  Texto tipo 'rfc822-headers'
	KMimeTextRfc822Headers Mime = "text/rfc822-headers"

	// KMimeTextRichtext
	//
	// English:
	//
	//  Text type 'richtext'
	//
	// Português:
	//
	//  Texto tipo 'richtext'
	KMimeTextRichtext Mime = "[RFC2045][RFC2046]"

	// KMimeTextRtf
	//
	// English:
	//
	//  Text type 'rtf'
	//
	// Português:
	//
	//  Texto tipo 'rtf'
	KMimeTextRtf Mime = "text/rtf"

	// KMimeTextRtpEncAescm128
	//
	// English:
	//
	//  Text type 'rtp-enc-aescm128'
	//
	// Português:
	//
	//  Texto tipo 'rtp-enc-aescm128'
	KMimeTextRtpEncAescm128 Mime = "text/rtp-enc-aescm128"

	// KMimeTextRtploopback
	//
	// English:
	//
	//  Text type 'rtploopback'
	//
	// Português:
	//
	//  Texto tipo 'rtploopback'
	KMimeTextRtploopback Mime = "text/rtploopback"

	// KMimeTextRtx
	//
	// English:
	//
	//  Text type 'rtx'
	//
	// Português:
	//
	//  Texto tipo 'rtx'
	KMimeTextRtx Mime = "text/rtx"

	// KMimeTextSGML
	//
	// English:
	//
	//  Text type 'SGML'
	//
	// Português:
	//
	//  Texto tipo 'SGML'
	KMimeTextSGML Mime = "text/SGML"

	// KMimeTextShaclc
	//
	// English:
	//
	//  Text type 'shaclc'
	//
	// Português:
	//
	//  Texto tipo 'shaclc'
	KMimeTextShaclc Mime = "text/shaclc"

	// KMimeTextShex
	//
	// English:
	//
	//  Text type 'shex'
	//
	// Português:
	//
	//  Texto tipo 'shex'
	KMimeTextShex Mime = "text/shex"

	// KMimeTextSpdx
	//
	// English:
	//
	//  Text type 'spdx'
	//
	// Português:
	//
	//  Texto tipo 'spdx'
	KMimeTextSpdx Mime = "text/spdx"

	// KMimeTextStrings
	//
	// English:
	//
	//  Text type 'strings'
	//
	// Português:
	//
	//  Texto tipo 'strings'
	KMimeTextStrings Mime = "text/strings"

	// KMimeTextT140
	//
	// English:
	//
	//  Text type 't140'
	//
	// Português:
	//
	//  Texto tipo 't140'
	KMimeTextT140 Mime = "text/t140"

	// KMimeTextTabSeparatedValues
	//
	// English:
	//
	//  Text type 'tab-separated-values'
	//
	// Português:
	//
	//  Texto tipo 'tab-separated-values'
	KMimeTextTabSeparatedValues Mime = "text/tab-separated-values"

	// KMimeTextTroff
	//
	// English:
	//
	//  Text type 'troff'
	//
	// Português:
	//
	//  Texto tipo 'troff'
	KMimeTextTroff Mime = "text/troff"

	// KMimeTextTurtle
	//
	// English:
	//
	//  Text type 'turtle'
	//
	// Português:
	//
	//  Texto tipo 'turtle'
	KMimeTextTurtle Mime = "text/turtle"

	// KMimeTextUlpfec
	//
	// English:
	//
	//  Text type 'ulpfec'
	//
	// Português:
	//
	//  Texto tipo 'ulpfec'
	KMimeTextUlpfec Mime = "text/ulpfec"

	// KMimeTextUriList
	//
	// English:
	//
	//  Text type 'uri-list'
	//
	// Português:
	//
	//  Texto tipo 'uri-list'
	KMimeTextUriList Mime = "text/uri-list"

	// KMimeTextVcard
	//
	// English:
	//
	//  Text type 'vcard'
	//
	// Português:
	//
	//  Texto tipo 'vcard'
	KMimeTextVcard Mime = "text/vcard"

	// KMimeTextVndA
	//
	// English:
	//
	//  Text type 'vnd.a'
	//
	// Português:
	//
	//  Texto tipo 'vnd.a'
	KMimeTextVndA Mime = "text/vnd.a"

	// KMimeTextVndAbc
	//
	// English:
	//
	//  Text type 'vnd.abc'
	//
	// Português:
	//
	//  Texto tipo 'vnd.abc'
	KMimeTextVndAbc Mime = "text/vnd.abc"

	// KMimeTextVndAsciiArt
	//
	// English:
	//
	//  Text type 'vnd.ascii-art'
	//
	// Português:
	//
	//  Texto tipo 'vnd.ascii-art'
	KMimeTextVndAsciiArt Mime = "text/vnd.ascii-art"

	// KMimeTextVndCurl
	//
	// English:
	//
	//  Text type 'vnd.curl'
	//
	// Português:
	//
	//  Texto tipo 'vnd.curl'
	KMimeTextVndCurl Mime = "text/vnd.curl"

	// KMimeTextVndDebianCopyright
	//
	// English:
	//
	//  Text type 'vnd.debian.copyright'
	//
	// Português:
	//
	//  Texto tipo 'vnd.debian.copyright'
	KMimeTextVndDebianCopyright Mime = "text/vnd.debian.copyright"

	// KMimeTextVndDMClientScript
	//
	// English:
	//
	//  Text type 'vnd.DMClientScript'
	//
	// Português:
	//
	//  Texto tipo 'vnd.DMClientScript'
	KMimeTextVndDMClientScript Mime = "text/vnd.DMClientScript"

	// KMimeTextVndDvbSubtitle
	//
	// English:
	//
	//  Text type 'vnd.dvb.subtitle'
	//
	// Português:
	//
	//  Texto tipo 'vnd.dvb.subtitle'
	KMimeTextVndDvbSubtitle Mime = "text/vnd.dvb.subtitle"

	// KMimeTextVndEsmertecThemeDescriptor
	//
	// English:
	//
	//  Text type 'vnd.esmertec.theme-descriptor'
	//
	// Português:
	//
	//  Texto tipo 'vnd.esmertec.theme-descriptor'
	KMimeTextVndEsmertecThemeDescriptor Mime = "text/vnd.esmertec.theme-descriptor"

	// KMimeTextVndFamilysearchGedcom
	//
	// English:
	//
	//  Text type 'vnd.familysearch.gedcom'
	//
	// Português:
	//
	//  Texto tipo 'vnd.familysearch.gedcom'
	KMimeTextVndFamilysearchGedcom Mime = "text/vnd.familysearch.gedcom"

	// KMimeTextVndFiclabFlt
	//
	// English:
	//
	//  Text type 'vnd.ficlab.flt'
	//
	// Português:
	//
	//  Texto tipo 'vnd.ficlab.flt'
	KMimeTextVndFiclabFlt Mime = "text/vnd.ficlab.flt"

	// KMimeTextVndFly
	//
	// English:
	//
	//  Text type 'vnd.fly'
	//
	// Português:
	//
	//  Texto tipo 'vnd.fly'
	KMimeTextVndFly Mime = "text/vnd.fly"

	// KMimeTextVndFmiFlexstor
	//
	// English:
	//
	//  Text type 'vnd.fmi.flexstor'
	//
	// Português:
	//
	//  Texto tipo 'vnd.fmi.flexstor'
	KMimeTextVndFmiFlexstor Mime = "text/vnd.fmi.flexstor"

	// KMimeTextVndGml
	//
	// English:
	//
	//  Text type 'vnd.gml'
	//
	// Português:
	//
	//  Texto tipo 'vnd.gml'
	KMimeTextVndGml Mime = "text/vnd.gml"

	// KMimeTextVndGraphviz
	//
	// English:
	//
	//  Text type 'vnd.graphviz'
	//
	// Português:
	//
	//  Texto tipo 'vnd.graphviz'
	KMimeTextVndGraphviz Mime = "text/vnd.graphviz"

	// KMimeTextVndHans
	//
	// English:
	//
	//  Text type 'vnd.hans'
	//
	// Português:
	//
	//  Texto tipo 'vnd.hans'
	KMimeTextVndHans Mime = "text/vnd.hans"

	// KMimeTextVndHgl
	//
	// English:
	//
	//  Text type 'vnd.hgl'
	//
	// Português:
	//
	//  Texto tipo 'vnd.hgl'
	KMimeTextVndHgl Mime = "text/vnd.hgl"

	// KMimeTextVndIn3d3dml
	//
	// English:
	//
	//  Text type 'vnd.in3d.3dml'
	//
	// Português:
	//
	//  Texto tipo 'vnd.in3d.3dml'
	KMimeTextVndIn3d3dml Mime = "text/vnd.in3d.3dml"

	// KMimeTextVndIn3dSpot
	//
	// English:
	//
	//  Text type 'vnd.in3d.spot'
	//
	// Português:
	//
	//  Texto tipo 'vnd.in3d.spot'
	KMimeTextVndIn3dSpot Mime = "text/vnd.in3d.spot"

	// KMimeTextVndIPTCNewsML
	//
	// English:
	//
	//  Text type 'vnd.IPTC.NewsML'
	//
	// Português:
	//
	//  Texto tipo 'vnd.IPTC.NewsML'
	KMimeTextVndIPTCNewsML Mime = "text/vnd.IPTC.NewsML"

	// KMimeTextVndIPTCNITF
	//
	// English:
	//
	//  Text type 'vnd.IPTC.NITF'
	//
	// Português:
	//
	//  Texto tipo 'vnd.IPTC.NITF'
	KMimeTextVndIPTCNITF Mime = "text/vnd.IPTC.NITF"

	// KMimeTextVndLatexZ
	//
	// English:
	//
	//  Text type 'vnd.latex-z'
	//
	// Português:
	//
	//  Texto tipo 'vnd.latex-z'
	KMimeTextVndLatexZ Mime = "text/vnd.latex-z"

	// KMimeTextVndMotorolaReflex
	//
	// English:
	//
	//  Text type 'vnd.motorola.reflex'
	//
	// Português:
	//
	//  Texto tipo 'vnd.motorola.reflex'
	KMimeTextVndMotorolaReflex Mime = "text/vnd.motorola.reflex"

	// KMimeTextVndMsMediapackage
	//
	// English:
	//
	//  Text type 'vnd.ms-mediapackage'
	//
	// Português:
	//
	//  Texto tipo 'vnd.ms-mediapackage'
	KMimeTextVndMsMediapackage Mime = "text/vnd.ms-mediapackage"

	// KMimeTextVndNet2phoneCommcenterCommand
	//
	// English:
	//
	//  Text type 'vnd.net2phone.commcenter.command'
	//
	// Português:
	//
	//  Texto tipo 'vnd.net2phone.commcenter.command'
	KMimeTextVndNet2phoneCommcenterCommand Mime = "text/vnd.net2phone.commcenter.command"

	// KMimeTextVndRadisysMsmlBasicLayout
	//
	// English:
	//
	//  Text type 'vnd.radisys.msml-basic-layout'
	//
	// Português:
	//
	//  Texto tipo 'vnd.radisys.msml-basic-layout'
	KMimeTextVndRadisysMsmlBasicLayout Mime = "text/vnd.radisys.msml-basic-layout"

	// KMimeTextVndSenxWarpscript
	//
	// English:
	//
	//  Text type 'vnd.senx.warpscript'
	//
	// Português:
	//
	//  Texto tipo 'vnd.senx.warpscript'
	KMimeTextVndSenxWarpscript Mime = "text/vnd.senx.warpscript"

	// KMimeTextVndSunJ2meAppDescriptor
	//
	// English:
	//
	//  Text type 'vnd.sun.j2me.app-descriptor'
	//
	// Português:
	//
	//  Texto tipo 'vnd.sun.j2me.app-descriptor'
	KMimeTextVndSunJ2meAppDescriptor Mime = "text/vnd.sun.j2me.app-descriptor"

	// KMimeTextVndSosi
	//
	// English:
	//
	//  Text type 'vnd.sosi'
	//
	// Português:
	//
	//  Texto tipo 'vnd.sosi'
	KMimeTextVndSosi Mime = "text/vnd.sosi"

	// KMimeTextVndTrolltechLinguist
	//
	// English:
	//
	//  Text type 'vnd.trolltech.linguist'
	//
	// Português:
	//
	//  Texto tipo 'vnd.trolltech.linguist'
	KMimeTextVndTrolltechLinguist Mime = "text/vnd.trolltech.linguist"

	// KMimeTextVndWapSi
	//
	// English:
	//
	//  Text type 'vnd.wap.si'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.si'
	KMimeTextVndWapSi Mime = "text/vnd.wap.si"

	// KMimeTextVndWapSl
	//
	// English:
	//
	//  Text type 'vnd.wap.sl'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.sl'
	KMimeTextVndWapSl Mime = "text/vnd.wap.sl"

	// KMimeTextVndWapWml
	//
	// English:
	//
	//  Text type 'vnd.wap.wml'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.wml'
	KMimeTextVndWapWml Mime = "text/vnd.wap.wml"

	// KMimeTextVndWapWmlscript
	//
	// English:
	//
	//  Text type 'vnd.wap.wmlscript'
	//
	// Português:
	//
	//  Texto tipo 'vnd.wap.wmlscript'
	KMimeTextVndWapWmlscript Mime = "text/vnd.wap.wmlscript"

	// KMimeTextVtt
	//
	// English:
	//
	//  Text type 'vtt'
	//
	// Português:
	//
	//  Texto tipo 'vtt'
	KMimeTextVtt Mime = "text/vtt"

	// KMimeTextXml
	//
	// English:
	//
	//  Text type 'xml'
	//
	// Português:
	//
	//  Texto tipo 'xml'
	KMimeTextXml Mime = "text/xml"

	// KMimeTextXmlExternalParsedEntity
	//
	// English:
	//
	//  Text type 'xml-external-parsed-entity'
	//
	// Português:
	//
	//  Texto tipo 'xml-external-parsed-entity'
	KMimeTextXmlExternalParsedEntity Mime = "text/xml-external-parsed-entity"
)
const (
	// KMimeVideo1dInterleavedParityfec
	//
	// English:
	//
	//  Video type '1d-interleaved-parityfec'
	//
	// Português:
	//
	//  Vídeo tipo '1d-interleaved-parityfec'
	KMimeVideo1dInterleavedParityfec Mime = "video/1d-interleaved-parityfec"

	// KMimeVideo3gpp
	//
	// English:
	//
	//  Video type '3gpp'
	//
	// Português:
	//
	//  Vídeo tipo '3gpp'
	KMimeVideo3gpp Mime = "video/3gpp"

	// KMimeVideo3gpp2
	//
	// English:
	//
	//  Video type '3gpp2'
	//
	// Português:
	//
	//  Vídeo tipo '3gpp2'
	KMimeVideo3gpp2 Mime = "video/3gpp2"

	// KMimeVideo3gppTt
	//
	// English:
	//
	//  Video type '3gpp-tt'
	//
	// Português:
	//
	//  Vídeo tipo '3gpp-tt'
	KMimeVideo3gppTt Mime = "video/3gpp-tt"

	// KMimeVideoAV1
	//
	// English:
	//
	//  Video type 'AV1'
	//
	// Português:
	//
	//  Vídeo tipo 'AV1'
	KMimeVideoAV1 Mime = "video/AV1"

	// KMimeVideoBMPEG
	//
	// English:
	//
	//  Video type 'BMPEG'
	//
	// Português:
	//
	//  Vídeo tipo 'BMPEG'
	KMimeVideoBMPEG Mime = "video/BMPEG"

	// KMimeVideoBT656
	//
	// English:
	//
	//  Video type 'BT656'
	//
	// Português:
	//
	//  Vídeo tipo 'BT656'
	KMimeVideoBT656 Mime = "video/BT656"

	// KMimeVideoCelB
	//
	// English:
	//
	//  Video type 'CelB'
	//
	// Português:
	//
	//  Vídeo tipo 'CelB'
	KMimeVideoCelB Mime = "video/CelB"

	// KMimeVideoDV
	//
	// English:
	//
	//  Video type 'DV'
	//
	// Português:
	//
	//  Vídeo tipo 'DV'
	KMimeVideoDV Mime = "video/DV"

	// KMimeVideoEncaprtp
	//
	// English:
	//
	//  Video type 'encaprtp'
	//
	// Português:
	//
	//  Vídeo tipo 'encaprtp'
	KMimeVideoEncaprtp Mime = "video/encaprtp"

	// KMimeVideoExample
	//
	// English:
	//
	//  Video type 'example'
	//
	// Português:
	//
	//  Vídeo tipo 'example'
	KMimeVideoExample Mime = "video/example"

	// KMimeVideoFFV1
	//
	// English:
	//
	//  Video type 'FFV1'
	//
	// Português:
	//
	//  Vídeo tipo 'FFV1'
	KMimeVideoFFV1 Mime = "video/FFV1"

	// KMimeVideoFlexfec
	//
	// English:
	//
	//  Video type 'flexfec'
	//
	// Português:
	//
	//  Vídeo tipo 'flexfec'
	KMimeVideoFlexfec Mime = "video/flexfec"

	// KMimeVideoH261
	//
	// English:
	//
	//  Video type 'H261'
	//
	// Português:
	//
	//  Vídeo tipo 'H261'
	KMimeVideoH261 Mime = "video/H261"

	// KMimeVideoH263
	//
	// English:
	//
	//  Video type 'H263'
	//
	// Português:
	//
	//  Vídeo tipo 'H263'
	KMimeVideoH263 Mime = "video/H263"

	// KMimeVideoH2631998
	//
	// English:
	//
	//  Video type 'H263-1998'
	//
	// Português:
	//
	//  Vídeo tipo 'H263-1998'
	KMimeVideoH2631998 Mime = "video/H263-1998"

	// KMimeVideoH2632000
	//
	// English:
	//
	//  Video type 'H263-2000'
	//
	// Português:
	//
	//  Vídeo tipo 'H263-2000'
	KMimeVideoH2632000 Mime = "video/H263-2000"

	// KMimeVideoH264
	//
	// English:
	//
	//  Video type 'H264'
	//
	// Português:
	//
	//  Vídeo tipo 'H264'
	KMimeVideoH264 Mime = "video/H264"

	// KMimeVideoH264RCDO
	//
	// English:
	//
	//  Video type 'H264-RCDO'
	//
	// Português:
	//
	//  Vídeo tipo 'H264-RCDO'
	KMimeVideoH264RCDO Mime = "video/H264-RCDO"

	// KMimeVideoH264SVC
	//
	// English:
	//
	//  Video type 'H264-SVC'
	//
	// Português:
	//
	//  Vídeo tipo 'H264-SVC'
	KMimeVideoH264SVC Mime = "video/H264-SVC"

	// KMimeVideoH265
	//
	// English:
	//
	//  Video type 'H265'
	//
	// Português:
	//
	//  Vídeo tipo 'H265'
	KMimeVideoH265 Mime = "video/H265"

	// KMimeVideoIsoSegment
	//
	// English:
	//
	//  Video type 'iso.segment'
	//
	// Português:
	//
	//  Vídeo tipo 'iso.segment'
	KMimeVideoIsoSegment Mime = "video/iso.segment"

	// KMimeVideoJPEG
	//
	// English:
	//
	//  Video type 'JPEG'
	//
	// Português:
	//
	//  Vídeo tipo 'JPEG'
	KMimeVideoJPEG Mime = "video/JPEG"

	// KMimeVideoJpeg2000
	//
	// English:
	//
	//  Video type 'jpeg2000'
	//
	// Português:
	//
	//  Vídeo tipo 'jpeg2000'
	KMimeVideoJpeg2000 Mime = "video/jpeg2000"

	// KMimeVideoJxsv
	//
	// English:
	//
	//  Video type 'jxsv'
	//
	// Português:
	//
	//  Vídeo tipo 'jxsv'
	KMimeVideoJxsv Mime = "video/jxsv"

	// KMimeVideoMj2
	//
	// English:
	//
	//  Video type 'mj2'
	//
	// Português:
	//
	//  Vídeo tipo 'mj2'
	KMimeVideoMj2 Mime = "video/mj2"

	// KMimeVideoMP1S
	//
	// English:
	//
	//  Video type 'MP1S'
	//
	// Português:
	//
	//  Vídeo tipo 'MP1S'
	KMimeVideoMP1S Mime = "video/MP1S"

	// KMimeVideoMP2P
	//
	// English:
	//
	//  Video type 'MP2P'
	//
	// Português:
	//
	//  Vídeo tipo 'MP2P'
	KMimeVideoMP2P Mime = "video/MP2P"

	// KMimeVideoMP2T
	//
	// English:
	//
	//  Video type 'MP2T'
	//
	// Português:
	//
	//  Vídeo tipo 'MP2T'
	KMimeVideoMP2T Mime = "video/MP2T"

	// KMimeVideoMp4
	//
	// English:
	//
	//  Video type 'mp4'
	//
	// Português:
	//
	//  Vídeo tipo 'mp4'
	KMimeVideoMp4 Mime = "video/mp4"

	// KMimeVideoMP4VES
	//
	// English:
	//
	//  Video type 'MP4V-ES'
	//
	// Português:
	//
	//  Vídeo tipo 'MP4V-ES'
	KMimeVideoMP4VES Mime = "video/MP4V-ES"

	// KMimeVideoMPV
	//
	// English:
	//
	//  Video type 'MPV'
	//
	// Português:
	//
	//  Vídeo tipo 'MPV'
	KMimeVideoMPV Mime = "video/MPV"

	// KMimeVideoMpeg
	//
	// English:
	//
	//  Video type 'mpeg'
	//
	// Português:
	//
	//  Vídeo tipo 'mpeg'
	KMimeVideoMpeg Mime = "[RFC2045][RFC2046]"

	// KMimeVideoMpeg4Generic
	//
	// English:
	//
	//  Video type 'mpeg4-generic'
	//
	// Português:
	//
	//  Vídeo tipo 'mpeg4-generic'
	KMimeVideoMpeg4Generic Mime = "video/mpeg4-generic"

	// KMimeVideoNv
	//
	// English:
	//
	//  Video type 'nv'
	//
	// Português:
	//
	//  Vídeo tipo 'nv'
	KMimeVideoNv Mime = "video/nv"

	// KMimeVideoOgg
	//
	// English:
	//
	//  Video type 'ogg'
	//
	// Português:
	//
	//  Vídeo tipo 'ogg'
	KMimeVideoOgg Mime = "video/ogg"

	// KMimeVideoParityfec
	//
	// English:
	//
	//  Video type 'parityfec'
	//
	// Português:
	//
	//  Vídeo tipo 'parityfec'
	KMimeVideoParityfec Mime = "video/parityfec"

	// KMimeVideoPointer
	//
	// English:
	//
	//  Video type 'pointer'
	//
	// Português:
	//
	//  Vídeo tipo 'pointer'
	KMimeVideoPointer Mime = "video/pointer"

	// KMimeVideoQuicktime
	//
	// English:
	//
	//  Video type 'quicktime'
	//
	// Português:
	//
	//  Vídeo tipo 'quicktime'
	KMimeVideoQuicktime Mime = "video/quicktime"

	// KMimeVideoRaptorfec
	//
	// English:
	//
	//  Video type 'raptorfec'
	//
	// Português:
	//
	//  Vídeo tipo 'raptorfec'
	KMimeVideoRaptorfec Mime = "video/raptorfec"

	// KMimeVideoRaw
	//
	// English:
	//
	//  Video type 'raw'
	//
	// Português:
	//
	//  Vídeo tipo 'raw'
	KMimeVideoRaw Mime = "video/raw"

	// KMimeVideoRtpEncAescm128
	//
	// English:
	//
	//  Video type 'rtp-enc-aescm128'
	//
	// Português:
	//
	//  Vídeo tipo 'rtp-enc-aescm128'
	KMimeVideoRtpEncAescm128 Mime = "video/rtp-enc-aescm128"

	// KMimeVideoRtploopback
	//
	// English:
	//
	//  Video type 'rtploopback'
	//
	// Português:
	//
	//  Vídeo tipo 'rtploopback'
	KMimeVideoRtploopback Mime = "video/rtploopback"

	// KMimeVideoRtx
	//
	// English:
	//
	//  Video type 'rtx'
	//
	// Português:
	//
	//  Vídeo tipo 'rtx'
	KMimeVideoRtx Mime = "video/rtx"

	// KMimeVideoScip
	//
	// English:
	//
	//  Video type 'scip'
	//
	// Português:
	//
	//  Vídeo tipo 'scip'
	KMimeVideoScip Mime = "video/scip"

	// KMimeVideoSmpte291
	//
	// English:
	//
	//  Video type 'smpte291'
	//
	// Português:
	//
	//  Vídeo tipo 'smpte291'
	KMimeVideoSmpte291 Mime = "video/smpte291"

	// KMimeVideoSMPTE292M
	//
	// English:
	//
	//  Video type 'SMPTE292M'
	//
	// Português:
	//
	//  Vídeo tipo 'SMPTE292M'
	KMimeVideoSMPTE292M Mime = "video/SMPTE292M"

	// KMimeVideoUlpfec
	//
	// English:
	//
	//  Video type 'ulpfec'
	//
	// Português:
	//
	//  Vídeo tipo 'ulpfec'
	KMimeVideoUlpfec Mime = "video/ulpfec"

	// KMimeVideoVc1
	//
	// English:
	//
	//  Video type 'vc1'
	//
	// Português:
	//
	//  Vídeo tipo 'vc1'
	KMimeVideoVc1 Mime = "video/vc1"

	// KMimeVideoVc2
	//
	// English:
	//
	//  Video type 'vc2'
	//
	// Português:
	//
	//  Vídeo tipo 'vc2'
	KMimeVideoVc2 Mime = "video/vc2"

	// KMimeVideoVndCCTV
	//
	// English:
	//
	//  Video type 'vnd.CCTV'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.CCTV'
	KMimeVideoVndCCTV Mime = "video/vnd.CCTV"

	// KMimeVideoVndDeceHd
	//
	// English:
	//
	//  Video type 'vnd.dece.hd'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.hd'
	KMimeVideoVndDeceHd Mime = "video/vnd.dece.hd"

	// KMimeVideoVndDeceMobile
	//
	// English:
	//
	//  Video type 'vnd.dece.mobile'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.mobile'
	KMimeVideoVndDeceMobile Mime = "video/vnd.dece.mobile"

	// KMimeVideoVndDeceMp4
	//
	// English:
	//
	//  Video type 'vnd.dece.mp4'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.mp4'
	KMimeVideoVndDeceMp4 Mime = "video/vnd.dece.mp4"

	// KMimeVideoVndDecePd
	//
	// English:
	//
	//  Video type 'vnd.dece.pd'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.pd'
	KMimeVideoVndDecePd Mime = "video/vnd.dece.pd"

	// KMimeVideoVndDeceSd
	//
	// English:
	//
	//  Video type 'vnd.dece.sd'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.sd'
	KMimeVideoVndDeceSd Mime = "video/vnd.dece.sd"

	// KMimeVideoVndDeceVideo
	//
	// English:
	//
	//  Video type 'vnd.dece.video'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dece.video'
	KMimeVideoVndDeceVideo Mime = "video/vnd.dece.video"

	// KMimeVideoVndDirectvMpeg
	//
	// English:
	//
	//  Video type 'vnd.directv.mpeg'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.directv.mpeg'
	KMimeVideoVndDirectvMpeg Mime = "video/vnd.directv.mpeg"

	// KMimeVideoVndDirectvMpegTts
	//
	// English:
	//
	//  Video type 'vnd.directv.mpeg-tts'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.directv.mpeg-tts'
	KMimeVideoVndDirectvMpegTts Mime = "video/vnd.directv.mpeg-tts"

	// KMimeVideoVndDlnaMpegTts
	//
	// English:
	//
	//  Video type 'vnd.dlna.mpeg-tts'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dlna.mpeg-tts'
	KMimeVideoVndDlnaMpegTts Mime = "video/vnd.dlna.mpeg-tts"

	// KMimeVideoVndDvbFile
	//
	// English:
	//
	//  Video type 'vnd.dvb.file'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.dvb.file'
	KMimeVideoVndDvbFile Mime = "video/vnd.dvb.file"

	// KMimeVideoVndFvt
	//
	// English:
	//
	//  Video type 'vnd.fvt'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.fvt'
	KMimeVideoVndFvt Mime = "video/vnd.fvt"

	// KMimeVideoVndHnsVideo
	//
	// English:
	//
	//  Video type 'vnd.hns.video'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.hns.video'
	KMimeVideoVndHnsVideo Mime = "video/vnd.hns.video"

	// KMimeVideoVndIptvforum1dparityfec1010
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.1dparityfec-1010'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.1dparityfec-1010'
	KMimeVideoVndIptvforum1dparityfec1010 Mime = "video/vnd.iptvforum.1dparityfec-1010"

	// KMimeVideoVndIptvforum1dparityfec2005
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.1dparityfec-2005'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.1dparityfec-2005'
	KMimeVideoVndIptvforum1dparityfec2005 Mime = "video/vnd.iptvforum.1dparityfec-2005"

	// KMimeVideoVndIptvforum2dparityfec1010
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.2dparityfec-1010'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.2dparityfec-1010'
	KMimeVideoVndIptvforum2dparityfec1010 Mime = "video/vnd.iptvforum.2dparityfec-1010"

	// KMimeVideoVndIptvforum2dparityfec2005
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.2dparityfec-2005'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.2dparityfec-2005'
	KMimeVideoVndIptvforum2dparityfec2005 Mime = "video/vnd.iptvforum.2dparityfec-2005"

	// KMimeVideoVndIptvforumTtsavc
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.ttsavc'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.ttsavc'
	KMimeVideoVndIptvforumTtsavc Mime = "video/vnd.iptvforum.ttsavc"

	// KMimeVideoVndIptvforumTtsmpeg2
	//
	// English:
	//
	//  Video type 'vnd.iptvforum.ttsmpeg2'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.iptvforum.ttsmpeg2'
	KMimeVideoVndIptvforumTtsmpeg2 Mime = "video/vnd.iptvforum.ttsmpeg2"

	// KMimeVideoVndMotorolaVideo
	//
	// English:
	//
	//  Video type 'vnd.motorola.video'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.motorola.video'
	KMimeVideoVndMotorolaVideo Mime = "video/vnd.motorola.video"

	// KMimeVideoVndMotorolaVideop
	//
	// English:
	//
	//  Video type 'vnd.motorola.videop'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.motorola.videop'
	KMimeVideoVndMotorolaVideop Mime = "video/vnd.motorola.videop"

	// KMimeVideoVndMpegurl
	//
	// English:
	//
	//  Video type 'vnd.mpegurl'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.mpegurl'
	KMimeVideoVndMpegurl Mime = "video/vnd.mpegurl"

	// KMimeVideoVndMsPlayreadyMediaPyv
	//
	// English:
	//
	//  Video type 'vnd.ms-playready.media.pyv'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.ms-playready.media.pyv'
	KMimeVideoVndMsPlayreadyMediaPyv Mime = "video/vnd.ms-playready.media.pyv"

	// KMimeVideoVndNokiaInterleavedMultimedia
	//
	// English:
	//
	//  Video type 'vnd.nokia.interleaved-multimedia'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.nokia.interleaved-multimedia'
	KMimeVideoVndNokiaInterleavedMultimedia Mime = "video/vnd.nokia.interleaved-multimedia"

	// KMimeVideoVndNokiaMp4vr
	//
	// English:
	//
	//  Video type 'vnd.nokia.mp4vr'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.nokia.mp4vr'
	KMimeVideoVndNokiaMp4vr Mime = "video/vnd.nokia.mp4vr"

	// KMimeVideoVndNokiaVideovoip
	//
	// English:
	//
	//  Video type 'vnd.nokia.videovoip'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.nokia.videovoip'
	KMimeVideoVndNokiaVideovoip Mime = "video/vnd.nokia.videovoip"

	// KMimeVideoVndObjectvideo
	//
	// English:
	//
	//  Video type 'vnd.objectvideo'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.objectvideo'
	KMimeVideoVndObjectvideo Mime = "video/vnd.objectvideo"

	// KMimeVideoVndRadgamettoolsBink
	//
	// English:
	//
	//  Video type 'vnd.radgamettools.bink'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.radgamettools.bink'
	KMimeVideoVndRadgamettoolsBink Mime = "video/vnd.radgamettools.bink"

	// KMimeVideoVndRadgamettoolsSmacker
	//
	// English:
	//
	//  Video type 'vnd.radgamettools.smacker'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.radgamettools.smacker'
	KMimeVideoVndRadgamettoolsSmacker Mime = "video/vnd.radgamettools.smacker"

	// KMimeVideoVndSealedMpeg1
	//
	// English:
	//
	//  Video type 'vnd.sealed.mpeg1'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealed.mpeg1'
	KMimeVideoVndSealedMpeg1 Mime = "video/vnd.sealed.mpeg1"

	// KMimeVideoVndSealedMpeg4
	//
	// English:
	//
	//  Video type 'vnd.sealed.mpeg4'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealed.mpeg4'
	KMimeVideoVndSealedMpeg4 Mime = "video/vnd.sealed.mpeg4"

	// KMimeVideoVndSealedSwf
	//
	// English:
	//
	//  Video type 'vnd.sealed.swf'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealed.swf'
	KMimeVideoVndSealedSwf Mime = "video/vnd.sealed.swf"

	// KMimeVideoVndSealedmediaSoftsealMov
	//
	// English:
	//
	//  Video type 'vnd.sealedmedia.softseal.mov'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.sealedmedia.softseal.mov'
	KMimeVideoVndSealedmediaSoftsealMov Mime = "video/vnd.sealedmedia.softseal.mov"

	// KMimeVideoVndUvvuMp4
	//
	// English:
	//
	//  Video type 'vnd.uvvu.mp4'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.uvvu.mp4'
	KMimeVideoVndUvvuMp4 Mime = "video/vnd.uvvu.mp4"

	// KMimeVideoVndYoutubeYt
	//
	// English:
	//
	//  Video type 'vnd.youtube.yt'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.youtube.yt'
	KMimeVideoVndYoutubeYt Mime = "video/vnd.youtube.yt"

	// KMimeVideoVndVivo
	//
	// English:
	//
	//  Video type 'vnd.vivo'
	//
	// Português:
	//
	//  Vídeo tipo 'vnd.vivo'
	KMimeVideoVndVivo Mime = "video/vnd.vivo"

	// KMimeVideoVP8
	//
	// English:
	//
	//  Video type 'VP8'
	//
	// Português:
	//
	//  Vídeo tipo 'VP8'
	KMimeVideoVP8 Mime = "video/VP8"

	// KMimeVideoVP9
	//
	// English:
	//
	//  Video type 'VP9'
	//
	// Português:
	//
	//  Vídeo tipo 'VP9'
	KMimeVideoVP9 Mime = "video/VP9"
)

func (Mime) String 

func (e Mime) String() string

type ReferrerPolicy 

type ReferrerPolicy string
const (
	// KRefPolicyNoReferrer
	//
	// English:
	//
	//  The Referer header will not be sent.
	//
	// Português:
	//
	//  O cabeçalho Referer não será enviado.
	KRefPolicyNoReferrer ReferrerPolicy = "no-referrer"

	// KRefPolicyNoReferrerWhenDowngrade
	//
	// English:
	//
	//  The Referer header will not be sent to origins without TLS (HTTPS).
	//
	// Português:
	//
	//  O cabeçalho Referer não será enviado para origens sem TLS (HTTPS).
	KRefPolicyNoReferrerWhenDowngrade ReferrerPolicy = "no-referrer-when-downgrade"

	// KRefPolicyOrigin
	//
	// English:
	//
	//  The sent referrer will be limited to the origin of the referring page: its scheme, host, and
	//  port.
	//
	// Português:
	//
	//  O referenciador enviado será limitado à origem da página de referência: seu esquema, host e
	//  porta.
	KRefPolicyOrigin ReferrerPolicy = "origin"

	// KRefPolicyOriginWhenCrossOrigin
	//
	// English:
	//
	//  The referrer sent to other origins will be limited to the scheme, the host, and the port.
	//  Navigations on the same origin will still include the path.
	//
	// Português:
	//
	//  O referenciador enviado para outras origens será limitado ao esquema, ao host e à porta.
	//  As navegações na mesma origem ainda incluirão o caminho.
	KRefPolicyOriginWhenCrossOrigin ReferrerPolicy = "origin-when-cross-origin"

	// KRefPolicySameOrigin
	//
	// English:
	//
	//  A referrer will be sent for same origin, but cross-origin requests will contain no referrer
	//  information.
	//
	// Português:
	//
	//  Um referenciador será enviado para a mesma origem, mas as solicitações de origem cruzada não
	//  conterão informações de referenciador.
	KRefPolicySameOrigin ReferrerPolicy = "same-origin"

	// KRefPolicyStrictOrigin
	//
	// English:
	//
	//  Only send the origin of the document as the referrer when the protocol security level stays the
	//  same (HTTPS→HTTPS), but don't send it to a less secure destination (HTTPS→HTTP).
	//
	// Português:
	//
	//  Só envie a origem do documento como referenciador quando o nível de segurança do protocolo
	//  permanecer o mesmo (HTTPS→HTTPS), mas não envie para um destino menos seguro (HTTPS→HTTP).
	KRefPolicyStrictOrigin ReferrerPolicy = "strict-origin"

	// KRefPolicyStrictOriginWhenCrossOrigin
	//
	// English:
	//
	//  Send a full URL when performing a same-origin request, only send the origin when the protocol
	//  security level stays the same (HTTPS→HTTPS), and send no header to a less secure destination
	//  (HTTPS→HTTP). (default)
	//
	// Português:
	//
	//  Envie uma URL completa ao realizar uma solicitação de mesma origem, envie a origem apenas quando
	//  o nível de segurança do protocolo permanecer o mesmo (HTTPS→HTTPS) e não envie nenhum cabeçalho
	//  para um destino menos seguro (HTTPS→HTTP). (padrão)
	KRefPolicyStrictOriginWhenCrossOrigin ReferrerPolicy = "strict-origin-when-cross-origin"

	// KRefPolicyUnsafeUrl
	//
	// English:
	//
	//  The referrer will include the origin and the path (but not the fragment, password, or username).
	//  This value is unsafe, because it leaks origins and paths from TLS-protected resources to
	//  insecure origins.
	//
	// Português:
	//
	//  O referenciador incluirá a origem e o caminho (mas não o fragmento, a senha ou o nome de
	//  usuário).
	//  Esse valor não é seguro porque vaza origens e caminhos de recursos protegidos por TLS para
	//  origens inseguras.
	KRefPolicyUnsafeUrl ReferrerPolicy = "unsafe-url"
)

func (ReferrerPolicy) String 

func (e ReferrerPolicy) String() string

type Scheme 

type Scheme string
const (
	KSchemeBitcoin     Scheme = "bitcoin"
	KSchemeFtp         Scheme = "ftp"
	KSchemeFtps        Scheme = "ftps"
	KSchemeGeo         Scheme = "geo"
	KSchemeIm          Scheme = "im"
	KSchemeIrc         Scheme = "irc"
	KSchemeIrcs        Scheme = "ircs"
	KSchemeMagnet      Scheme = "magnet"
	KSchemeMailTo      Scheme = "mailto"
	KSchemeMatrix      Scheme = "matrix"
	KSchemeMms         Scheme = "mms"
	KSchemeNews        Scheme = "news"
	KSchemeNntp        Scheme = "nntp"
	KSchemeOpenPgp4Fpr Scheme = "openpgp4fpr"
	KSchemeSftp        Scheme = "sftp"
	KSchemeSip         Scheme = "sip"
	KSchemeSms         Scheme = "sms"
	KSchemeSmsTo       Scheme = "smsto"
	KSchemeSsh         Scheme = "ssh"
	KSchemeTel         Scheme = "tel"
	KSchemeUrn         Scheme = "urn"
	KSchemeWebCal      Scheme = "webcal"
	KSchemeWtai        Scheme = "wtai"
	KSchemeXmpp        Scheme = "xmpp"
)

func (Scheme) String 

func (e Scheme) String() string

type Tag 

type Tag string
const (
	// KTagA
	//
	// English:
	//
	//  The Anchor element.
	//
	// The <a> HTML element (or anchor element), with its href attribute, creates a hyperlink to web
	// pages, files, email addresses, locations in the same page, or anything else a URL can address.
	//
	// Content within each <a> should indicate the link's destination. If the href attribute is present,
	// pressing the enter key while focused on the <a> element will activate it.
	//
	// Português
	//
	//  O elemento Âncora.
	//
	// O elemento HTML <a> (ou elemento âncora), com seu atributo href, cria um hiperlink para páginas
	// da web, arquivos, endereços de e-mail, locais na mesma página ou qualquer outra coisa que um URL
	// possa endereçar.
	//
	// O conteúdo de cada <a> deve indicar o destino do link. Se o atributo href estiver presente,
	// pressionar a tecla enter enquanto estiver focado no elemento <a> irá ativá-lo.
	KTagA Tag = "a"

	// KTagAbbr
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagAbbr Tag = "abbr"

	// KTagAddress
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagAddress Tag = "address"

	// KTagArea
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagArea Tag = "area"

	// KTagArticle
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagArticle Tag = "article"

	// KTagAside
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagAside Tag = "aside"

	// KTagAudio
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagAudio Tag = "audio"

	// KTagB
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagB Tag = "b"

	// KTagBase
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagBase Tag = "base"

	// KTagBdi
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagBdi Tag = "bdi"

	// KTagBdo
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagBdo Tag = "bdo"

	// KTagBlockquote
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagBlockquote Tag = "blockquote"

	// KTagBody
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagBody Tag = "body"

	// KTagBr
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagBr Tag = "br"

	// KTagButton
	//
	// English:
	//
	//  The <button> HTML element is an interactive element activated by a user with a mouse, keyboard, finger, voice command, or other assistive technology. Once activated, it then performs a programmable action, such as submitting a form or opening a dialog.
	//
	// By default, HTML buttons are presented in a style resembling the platform the user agent runs on, but you can change buttons' appearance with CSS.
	//
	// Português
	//
	//  O elemento HTML <button> é um elemento interativo ativado por um usuário com mouse, teclado,
	//  dedo, comando de voz ou outra tecnologia assistiva. Uma vez ativado, ele executa uma ação
	//  programável, como enviar um formulário ou abrir uma caixa de diálogo.
	//
	// Por padrão, os botões HTML são apresentados em um estilo semelhante à plataforma na qual o agente
	// do usuário é executado, mas você pode alterar a aparência dos botões com CSS.
	KTagButton Tag = "button"

	// KTagCanvas
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagCanvas Tag = "canvas"

	// KTagCaption
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagCaption Tag = "caption"

	// KTagCite
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagCite Tag = "cite"

	// KTagCode
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagCode Tag = "code"

	// KTagCol
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagCol Tag = "col"

	// KTagColgroup
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagColgroup Tag = "colgroup"

	// KTagData
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagData Tag = "data"

	// KTagDatalist
	//
	// English:
	//
	//  The <datalist> HTML element contains a set of <option> elements that represent the permissible
	//  or recommended options available to choose from within other controls.
	//
	// Português
	//
	//  O elemento HTML <datalist> contém um conjunto de elementos <option> que representam as opções
	//  permitidas ou recomendadas disponíveis para escolha em outros controles.
	KTagDatalist Tag = "datalist"

	// KTagDd
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDd Tag = "dd"

	// KTagDel
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDel Tag = "del"

	// KTagDetails
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDetails Tag = "details"

	// KTagDfn
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDfn Tag = "dfn"

	// KTagDialog
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDialog Tag = "dialog"

	// KTagDiv
	//
	//
	// English:
	//
	//  The <div> tag defines a division or a section in an HTML document.
	//
	//   Note:
	//     * By default, browsers always place a line break before and after the <div> element;
	//     * The <div> tag is used as a container for HTML elements - which is then styled with CSS or
	//       manipulated with JavaScript;
	//     * The <div> tag is easily styled by using the class or id attribute;
	//     * Any sort of content can be put inside the <div> tag.
	//
	// Português:
	//
	//  A tag <div> define uma divisão ou uma seção em um documento HTML.
	//
	//   Nota:
	//     * Por padrão, os navegadores sempre colocam uma quebra de linha antes e depois do elemento
	//       <div>;
	//     * A tag <div> é usada como um contêiner para elementos HTML - que são estilizados com CSS ou
	//       manipulados com JavaScript
	//     * A tag <div> é facilmente estilizada usando o atributo class ou id;
	//     * Qualquer tipo de conteúdo pode ser colocado dentro da tag <div>.
	KTagDiv Tag = "div"

	// KTagDl
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDl Tag = "dl"

	// KTagDt
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagDt Tag = "dt"

	// KTagEm
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagEm Tag = "em"

	// KTagEmbed
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagEmbed Tag = "embed"

	// KTagFieldset
	//
	// English:
	//
	//  The <fieldset> HTML element is used to group several controls as well as labels (<label>)
	//  within a web form.
	//
	// Português
	//
	//  O elemento HTML <fieldset> é usado para agrupar vários controles, bem como rótulos (<label>)
	//  dentro de um formulário web.
	KTagFieldset Tag = "fieldset"

	// KTagFigcaption
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagFigcaption Tag = "figcaption"

	// KTagFigure
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagFigure Tag = "figure"

	// KTagFooter
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagFooter Tag = "footer"

	// KTagForm
	//
	// English:
	//
	//  The <form> HTML element represents a document section containing interactive controls for
	//  submitting information.
	//
	// Português
	//
	//  O elemento HTML <form> representa uma seção do documento contendo controles interativos para o
	//  envio de informações.
	KTagForm Tag = "form"

	// KTagHead
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagHead Tag = "head"

	// KTagHeader
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagHeader Tag = "header"

	// KTagH1
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagH1 Tag = "h1"

	// KTagHr
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagHr Tag = "hr"

	// KTagHtml
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagHtml Tag = "html"

	// KTagI
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagI Tag = "i"

	// KTagIframe
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagIframe Tag = "iframe"

	// KTagImg
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagImg Tag = "img"

	// KTagInput
	//
	// English:
	//
	//  The <input> HTML element is used to create interactive controls for web-based forms in order to
	//  accept data from the user; a wide variety of types of input data and control widgets are
	//  available, depending on the device and user agent.
	//
	// The <input> element is one of the most powerful and complex in all of HTML due to the sheer
	// number of combinations of input types and attributes.
	//
	// Português
	//
	//  O elemento HTML <input> é usado para criar controles interativos para formulários baseados na
	//  web para aceitar dados do usuário; uma ampla variedade de tipos de dados de entrada e widgets
	//  de controle estão disponíveis, dependendo do dispositivo e do agente do usuário.
	//
	// O elemento <input> é um dos mais poderosos e complexos dentro do HTML, devido ao grande número
	// de combinações de tipos de entrada e atributos.
	KTagInput Tag = "input"

	// KTagIns
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagIns Tag = "ins"

	// KTagKbd
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagKbd Tag = "kbd"

	// KTagLabel
	//
	// English:
	//
	//  The <label> HTML element represents a caption for an item in a user interface.
	//
	// Português
	//
	//  O elemento HTML <label> representa uma legenda para um item em uma interface do usuário.
	KTagLabel Tag = "label"

	// KTagLegend
	//
	// English:
	//
	//  The <legend> HTML element represents a caption for the content of its parent <fieldset>.
	//
	// Português
	//
	//  O elemento HTML <legend> representa uma legenda para o conteúdo de seu <fieldset> pai.
	KTagLegend Tag = "legend"

	// KTagLi
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagLi Tag = "li"

	// KTagLink
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagLink Tag = "link"

	// KTagMain
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagMain Tag = "main"

	// KTagMap
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagMap Tag = "map"

	// KTagMark
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagMark Tag = "mark"

	// KTagExperimental
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagExperimental Tag = "Experimental"

	// KTagMenu
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagMenu Tag = "menu"

	// KTagMeta
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagMeta Tag = "meta"

	// KTagMeter
	//
	// English:
	//
	//  The <meter> HTML element represents either a scalar value within a known range or a fractional
	//  value.
	//
	// Português
	//
	//  O elemento HTML <meter> representa um valor escalar dentro de um intervalo conhecido ou um
	//  valor fracionário.
	KTagMeter Tag = "meter"

	// KTagNav
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagNav Tag = "nav"

	// KTagNoscript
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagNoscript Tag = "noscript"

	// KTagObject
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagObject Tag = "object"

	// KTagOl
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagOl Tag = "ol"

	// KTagOptgroup
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagOptgroup Tag = "optgroup"

	// KTagOption
	//
	// English:
	//
	//  The <option> HTML element is used to define an item contained in a <select>, an <optgroup>, or a
	//  <datalist> element. As such, <option> can represent menu items in popups and other lists of
	//  items in an HTML document.
	//
	// Português
	//
	//  O elemento HTML <option> é usado para definir um item contido em um elemento <select>,
	//  <optgroup> ou <datalist>. Como tal, <option> pode representar itens de menu em pop-ups e outras
	//  listas de itens em um documento HTML.
	KTagOption Tag = "option"

	// KTagOptionGroup
	//
	// English:
	//
	//  The <optgroup> HTML element creates a grouping of options within a <select> element.
	//
	// Português
	//
	//  O elemento HTML <optgroup> cria um agrupamento de opções dentro de um elemento <select>.
	KTagOptionGroup Tag = "optgroup"

	// KTagOutput
	//
	// English:
	//
	//  The <output> HTML element is a container element into which a site or app can inject the results
	//  of a calculation or the outcome of a user action.
	//
	// Português
	//
	//  O elemento HTML <output> é um elemento de contêiner no qual um site ou aplicativo pode injetar
	//  os resultados de um cálculo ou o resultado de uma ação do usuário.
	KTagOutput Tag = "output"

	// KTagP
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagP Tag = "p"

	// KTagParam
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagParam Tag = "param"

	// KTagPicture
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagPicture Tag = "picture"

	// KTagPortal
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagPortal Tag = "portal"

	// KTagPre
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagPre Tag = "pre"

	// KTagProgress
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagProgress Tag = "progress"

	// KTagQ
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagQ Tag = "q"

	// KTagRp
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagRp Tag = "rp"

	// KTagRt
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagRt Tag = "rt"

	// KTagRuby
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagRuby Tag = "ruby"

	// KTagS
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagS Tag = "s"

	// KTagSamp
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSamp Tag = "samp"

	// KTagScript
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagScript Tag = "script"

	// KTagSection
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSection Tag = "section"

	// KTagSelect
	//
	// English:
	//
	//  The <select> HTML element represents a control that provides a menu of options.
	//
	// Português
	//
	//  O elemento HTML <select> representa um controle que fornece um menu de opções.
	KTagSelect Tag = "select"

	// KTagSlot
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSlot Tag = "slot"

	// KTagSmall
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSmall Tag = "small"

	// KTagSource
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSource Tag = "source"

	// KTagSpan
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSpan Tag = "span"

	// KTagStrong
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagStrong Tag = "strong"

	// KTagStyle
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagStyle Tag = "style"

	// KTagSub
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSub Tag = "sub"

	// KTagSummary
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSummary Tag = "summary"

	// KTagSup
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagSup Tag = "sup"

	// KTagTable
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTable Tag = "table"

	// KTagTbody
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTbody Tag = "tbody"

	// KTagTd
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTd Tag = "td"

	// KTagTemplate
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTemplate Tag = "template"

	// KTagTextarea
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTextarea Tag = "textarea"

	// KTagTfoot
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTfoot Tag = "tfoot"

	// KTagTh
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTh Tag = "th"

	// KTagThead
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagThead Tag = "thead"

	// KTagTime
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTime Tag = "time"

	// KTagTitle
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTitle Tag = "title"

	// KTagTr
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTr Tag = "tr"

	// KTagTrack
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagTrack Tag = "track"

	// KTagU
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagU Tag = "u"

	// KTagUl
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagUl Tag = "ul"

	// KTagVar
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagVar Tag = "var"

	// KTagVideo
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagVideo Tag = "video"

	// KTagWbr
	//
	// English:
	//
	//
	//
	// Português
	//
	//
	KTagWbr Tag = "wbr"
)

func (Tag) String 

func (e Tag) String() string

type TagA 

type TagA struct {
	// contains filtered or unexported fields
}

TagA

English: 

The Anchor element.

The <a> HTML element (or anchor element), with its href attribute, creates a hyperlink to web pages, files, email addresses, locations in the same page, or anything else a URL can address.

Content within each <a> should indicate the link's destination. If the href attribute is present, pressing the enter key while focused on the <a> element will activate it.

Português 

O elemento Âncora.

O elemento HTML <a> (ou elemento âncora), com seu atributo href, cria um hiperlink para páginas da web, arquivos, endereços de e-mail, locais na mesma página ou qualquer outra coisa que um URL possa endereçar.

O conteúdo de cada <a> deve indicar o destino do link. Se o atributo href estiver presente, pressionar a tecla enter enquanto estiver focado no elemento <a> irá ativá-lo.

func (*TagA) AccessKey 

func (e *TagA) AccessKey(key string) (ref *TagA)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagA) Append 

func (e *TagA) Append(append interface{}) (ref *TagA)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagA) AppendById 

func (e *TagA) AppendById(appendId string) (ref *TagA)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagA) Autofocus 

func (e *TagA) Autofocus(autofocus bool) (ref *TagA)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagA) Class 

func (e *TagA) Class(class ...string) (ref *TagA)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagA) ContentEditable 

func (e *TagA) ContentEditable(editable bool) (ref *TagA)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagA) CreateElement 

func (e *TagA) CreateElement(tag Tag) (ref *TagA)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagA) Data 

func (e *TagA) Data(data map[string]string) (ref *TagA)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagA) Dir 

func (e *TagA) Dir(dir Dir) (ref *TagA)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagA) Download 

func (e *TagA) Download(download string) (ref *TagA)

Download

English: 

Causes the browser to treat the linked URL as a download. Can be used with or without a value

 Note:
   * Without a value, the browser will suggest a filename/extension, generated from various
     sources:
       The Content-Disposition HTTP header;
       The final segment in the URL path;
       The media type (from the Content-Type header, the start of a data: URL, or Blob.type for a
       blob: URL).
   * Defining a value suggests it as the filename. / and \ characters are converted to
     underscores (_). Filesystems may forbid other characters in filenames, so browsers will
     adjust the suggested name if necessary;
   * Download only works for same-origin URLs, or the blob: and data: schemes;
   * How browsers treat downloads varies by browser, user settings, and other factors. The user
     may be prompted before a download starts, or the file may be saved automatically, or it may
     open automatically, either in an external application or in the browser itself;
   * If the Content-Disposition header has different information from the download attribute,
     resulting behavior may differ:
       * If the header specifies a filename, it takes priority over a filename specified in the
         download attribute;
       * If the header specifies a disposition of inline, Chrome and Firefox prioritize the
         attribute and treat it as a download. Old Firefox versions (before 82) prioritize the
         header and will display the content inline.

Português: 

Faz com que o navegador trate a URL vinculada como um download. Pode ser usado com ou sem valor

 Nota:
   * Sem um valor, o navegador sugerirá uma extensão de nome de arquivo, gerada a partir de várias
     fontes:
       O cabeçalho HTTP Content-Disposition;
       O segmento final no caminho do URL;
       O tipo de mídia (do cabeçalho Content-Type, o início de um data: URL ou Blob.type para um
       blob: URL).
   * Definir um valor sugere-o como o nome do arquivo. / e \ caracteres são convertidos em
     sublinhados (_). Os sistemas de arquivos podem proibir outros caracteres em nomes de
     arquivos, portanto, os navegadores ajustarão o nome sugerido, se necessário;
   * O download funciona apenas para URLs de mesma origem, ou os esquemas blob: e data: schemes;
   * A forma como os navegadores tratam os downloads varia de acordo com o navegador, as
     configurações do usuário e outros fatores. O usuário pode ser avisado antes do início de um
     download, ou o arquivo pode ser salvo automaticamente, ou pode ser aberto automaticamente,
     seja em um aplicativo externo ou no próprio navegador;
   * Se o cabeçalho Content-Disposition tiver informações diferentes do atributo download, o
     comportamento resultante pode ser diferente:
       * Se o cabeçalho especificar um nome de arquivo, ele terá prioridade sobre um nome de
         arquivo especificado no atributo download;
       * Se o cabeçalho especificar uma disposição de inline, o Chrome e o Firefox priorizarão o
         atributo e o tratarão como um download. Versões antigas do Firefox (antes de 82)
         priorizam o cabeçalho e exibirão o conteúdo inline.

func (*TagA) Draggable 

func (e *TagA) Draggable(draggable Draggable) (ref *TagA)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagA) EnterKeyHint 

func (e *TagA) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagA)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
       editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
       editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

func (*TagA) GetX 

func (e *TagA) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagA) GetXY 

func (e *TagA) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagA) GetY 

func (e *TagA) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagA) HRef 

func (e *TagA) HRef(href string) (ref *TagA)

HRef

English: 

The URL that the hyperlink points to. Links are not restricted to HTTP-based URLs — they can use
any URL scheme supported by browsers:
  * Sections of a page with fragment URLs;
  * Pieces of media files with media fragments;
  * Telephone numbers with tel: URLs;
  * Email addresses with mailto: URLs;
  * While web browsers may not support other URL schemes, web sites can with
    registerProtocolHandler().

Português: 

A URL para a qual o hiperlink aponta. Os links não são restritos a URLs baseados em HTTP — eles
podem usar qualquer esquema de URL suportado pelos navegadores:
  * Seções de uma página com URLs de fragmento;
  * Pedaços de arquivos de mídia com fragmentos de mídia;
  * Números de telefone com tel: URLs;
  * Endereços de e-mail com mailto: URLs;
  * Embora os navegadores da Web possam não suportar outros esquemas de URL, os sites da Web podem
    com registerProtocolHandler().

func (*TagA) HRefLang 

func (e *TagA) HRefLang(hreflang string) (ref *TagA)

HRefLang

English: 

Hints at the human language of the linked URL. No built-in functionality. Allowed values are the
same as the global lang attribute.

Português: 

Dicas para a linguagem humana da URL vinculada. Nenhuma funcionalidade embutida. Os valores
permitidos são os mesmos do atributo lang global.

func (*TagA) Hidden 

func (e *TagA) Hidden() (ref *TagA)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagA) Id 

func (e *TagA) Id(id string) (ref *TagA)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagA) InputMode 

func (e *TagA) InputMode(inputMode InputMode) (ref *TagA)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents.

This allows a browser to display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagA) Is 

func (e *TagA) Is(is string) (ref *TagA)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagA) ItemDrop 

func (e *TagA) ItemDrop(itemprop string) (ref *TagA)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagA) ItemId 

func (e *TagA) ItemId(id string) (ref *TagA)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagA) ItemRef 

func (e *TagA) ItemRef(itemref string) (ref *TagA)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagA) ItemType 

func (e *TagA) ItemType(itemType string) (ref *TagA)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagA) Lang 

func (e *TagA) Lang(language Language) (ref *TagA)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagA) Nonce 

func (e *TagA) Nonce(part ...string) (ref *TagA)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and
style specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem
que o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagA) Ping 

func (e *TagA) Ping(ping ...string) (ref *TagA)

Ping

English: 

A space-separated list of URLs. When the link is followed, the browser will send POST requests
with the body PING to the URLs. Typically for tracking.

Português: 

Uma lista de URLs separados por espaços. Quando o link for seguido, o navegador enviará
solicitações POST com o corpo PING para as URLs. Normalmente para rastreamento.

func (*TagA) ReferrerPolicy 

func (e *TagA) ReferrerPolicy(referrerPolicy ReferrerPolicy) (ref *TagA)

ReferrerPolicy

English: 

How much of the referrer to send when following the link.

 KRefPolicyNoReferrer: The Referer header will not be sent.
 KRefPolicyNoReferrerWhenDowngrade: The Referer header will not be sent to origins without TLS
   (HTTPS).
 KRefPolicyOrigin: The sent referrer will be limited to the origin of the referring page: its
   scheme, host, and port.
 KRefPolicyOriginWhenCrossOrigin: The referrer sent to other origins will be limited to the
   scheme, the host, and the port. Navigations on the same origin will still include the path.
 KRefPolicySameOrigin: A referrer will be sent for same origin, but cross-origin requests will
   contain no referrer information.
 KRefPolicyStrictOrigin: Only send the origin of the document as the referrer when the protocol
   security level stays the same (HTTPS→HTTPS), but don't send it to a less secure destination
   (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (default): Send a full URL when performing a same-origin
   request, only send the origin when the protocol security level stays the same (HTTPS→HTTPS),
   and send no header to a less secure destination (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: The referrer will include the origin and the path (but not the fragment,
   password, or username). This value is unsafe, because it leaks origins and paths from
   TLS-protected resources to insecure origins.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

Português: 

Quanto do referenciador enviar ao seguir o link.

 KRefPolicyNoReferrer: O cabeçalho Referer não será enviado.
 KRefPolicyNoReferrerWhenDowngrade: O cabeçalho Referer não será enviado para origens sem
   TLS (HTTPS).
 KRefPolicyOrigin: O referenciador enviado será limitado à origem da página de referência: seu
   esquema, host e porta.
 KRefPolicyOriginWhenCrossOrigin: O referenciador enviado para outras origens será limitado ao
   esquema, ao host e à porta. As navegações na mesma origem ainda incluirão o caminho.
 KRefPolicySameOrigin: Um referenciador será enviado para a mesma origem, mas as solicitações
   de origem cruzada não conterão informações de referenciador.
 KRefPolicyStrictOrigin: Só envie a origem do documento como referenciador quando o nível de
   segurança do protocolo permanecer o mesmo (HTTPS→HTTPS), mas não envie para um destino menos
   seguro (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (padrão): Envie uma URL completa ao realizar uma
   solicitação de mesma origem, envie a origem apenas quando o nível de segurança do protocolo
   permanecer o mesmo (HTTPS→HTTPS) e não envie nenhum cabeçalho para um destino menos seguro
   (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: O referenciador incluirá a origem e o caminho (mas não o fragmento, a
   senha ou o nome de usuário). Esse valor não é seguro porque vaza origens e caminhos de
   recursos protegidos por TLS para origens inseguras.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

func (*TagA) Rel 

func (e *TagA) Rel(rel string) (ref *TagA)

Rel

English: 

The relationship of the linked URL as space-separated link types.

Português: 

O relacionamento da URL vinculada como tipos de link separados por espaço.

func (*TagA) SetX 

func (e *TagA) SetX(x int) (ref *TagA)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagA) SetXY 

func (e *TagA) SetXY(x, y int) (ref *TagA)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagA) SetY 

func (e *TagA) SetY(y int) (ref *TagA)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagA) Slot 

func (e *TagA) Slot(slot string) (ref *TagA)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that
slot attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagA) Spellcheck 

func (e *TagA) Spellcheck(spell bool) (ref *TagA)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagA) Style 

func (e *TagA) Style(style string) (ref *TagA)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagA) TabIndex 

func (e *TagA) TabIndex(index int) (ref *TagA)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagA) Target 

func (e *TagA) Target(target Target) (ref *TagA)

Target

English:

Where to display the linked URL, as the name for a browsing context (a tab, window, or <iframe>). The following keywords have special meanings for where to load the URL: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Note:
  * Setting target="_blank" on <a> elements implicitly provides the same rel behavior as setting
    rel="noopener" which does not set window.opener. See browser compatibility for support
    status.

Português:

Onde exibir a URL vinculada, como o nome de um contexto de navegação (uma guia, janela ou <iframe>). As seguintes palavras-chave têm significados especiais para onde carregar o URL: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

Nota:
  * Definir target="_blank" em elementos <a> fornece implicitamente o mesmo comportamento rel
    que definir rel="noopener" que não define window.opener. Consulte a compatibilidade do
    navegador para obter o status do suporte.

func (*TagA) Title 

func (e *TagA) Title(title string) (ref *TagA)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagA) Translate 

func (e *TagA) Translate(translate Translate) (ref *TagA)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagA) Type 

func (e *TagA) Type(typeProperty Mime) (ref *TagA)

Type

English:

Hints at the linked URL's format with a MIME type. No built-in functionality.

Português:

Dicas no formato do URL vinculado com um tipo MIME. Nenhuma funcionalidade embutida.

type TagButton 

type TagButton struct {
	// contains filtered or unexported fields
}

TagButton

English: 

The <button> HTML element is an interactive element activated by a user with a mouse, keyboard,
finger, voice command, or other assistive technology. Once activated, it then performs a
programmable action, such as submitting a form or opening a dialog.

By default, HTML buttons are presented in a style resembling the platform the user agent runs on, but you can change buttons' appearance with CSS.

Português 

O elemento HTML <button> é um elemento interativo ativado por um usuário com mouse, teclado,
dedo, comando de voz ou outra tecnologia assistiva. Uma vez ativado, ele executa uma ação
programável, como enviar um formulário ou abrir uma caixa de diálogo.

Por padrão, os botões HTML são apresentados em um estilo semelhante à plataforma na qual o agente do usuário é executado, mas você pode alterar a aparência dos botões com CSS.

func (*TagButton) AccessKey 

func (e *TagButton) AccessKey(key string) (ref *TagButton)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagButton) Append 

func (e *TagButton) Append(append interface{}) (ref *TagButton)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagButton) AppendById 

func (e *TagButton) AppendById(appendId string) (ref *TagButton)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagButton) Autocomplete 

func (e *TagButton) Autocomplete(autocomplete Autocomplete) (ref *TagButton)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagButton) Autofocus 

func (e *TagButton) Autofocus(autofocus bool) (ref *TagButton)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagButton) ButtonType 

func (e *TagButton) ButtonType(value ButtonType) (ref *TagButton)

ButtonType

English: 

The default behavior of the button.

 Input:
   value: default behavior of the button.
     KButtonTypeSubmit: The button submits the form data to the server. This is the default if
       the attribute is not specified for buttons associated with a <form>, or if the attribute
       is an empty or invalid value.
     KButtonTypeReset:  The button resets all the controls to their initial values, like
       <input type="reset">. (This behavior tends to annoy users.)
     KButtonTypeButton: The button has no default behavior, and does nothing when pressed by
       default. It can have client-side scripts listen to the element's events, which are
       triggered when the events occur.

Português: 

O comportamento padrão do botão. Os valores possíveis são:

 Entrada:
   value: comportamento padrão do botão
     KButtonTypeSubmit: O botão envia os dados do formulário para o servidor. Este é o padrão se
       o atributo não for especificado para botões associados a um <form> ou se o atributo for um
       valor vazio ou inválido.
     KButtonTypeReset:  O botão redefine todos os controles para seus valores iniciais, como
       <input type="reset">. (Esse comportamento tende a incomodar os usuários.)
     KButtonTypeButton: O botão não tem comportamento padrão e não faz nada quando pressionado por
       padrão. Ele pode fazer com que os scripts do lado do cliente escutem os eventos do
       elemento, que são acionados quando os eventos ocorrem.

func (*TagButton) Class 

func (e *TagButton) Class(class ...string) (ref *TagButton)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagButton) ContentEditable 

func (e *TagButton) ContentEditable(editable bool) (ref *TagButton)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagButton) CreateElement 

func (e *TagButton) CreateElement(tag Tag) (ref *TagButton)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagButton) Data 

func (e *TagButton) Data(data map[string]string) (ref *TagButton)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagButton) Dir 

func (e *TagButton) Dir(dir Dir) (ref *TagButton)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagButton) Disabled 

func (e *TagButton) Disabled(disabled bool) (ref *TagButton)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagButton) Draggable 

func (e *TagButton) Draggable(draggable Draggable) (ref *TagButton)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagButton) EnterKeyHint 

func (e *TagButton) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagButton)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagButton) Form 

func (e *TagButton) Form(form string) (ref *TagButton)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagButton) FormEncType 

func (e *TagButton) FormEncType(formenctype FormEncType) (ref *TagButton)

FormEncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagButton) FormMethod 

func (e *TagButton) FormMethod(method FormMethod) (ref *TagButton)

FormMethod

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials.
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login.
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagButton) FormTarget 

func (e *TagButton) FormTarget(formtarget Target) (ref *TagButton)

FormTarget

English: 

If the button is a submit button, this attribute is an author-defined name or standardized,
underscore-prefixed keyword indicating where to display the response from submitting the form.

This is the name of, or keyword for, a browsing context (a tab, window, or <iframe>).

If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Português: 

Se o botão for um botão de envio, esse atributo será um nome definido pelo autor ou uma
palavra-chave padronizada com prefixo de sublinhado indicando onde exibir a resposta do envio do
formulário.

Este é o nome ou a palavra-chave de um contexto de navegação (uma guia, janela ou <iframe>). Se este atributo for especificado, ele substituirá o atributo de destino do proprietário do formulário do botão. As seguintes palavras-chave têm significados especiais: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

func (*TagButton) FormValidate 

func (e *TagButton) FormValidate(validate bool) (ref *TagButton)

FormValidate

English: 

If the button is a submit button, 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.

Português: 

Se o botão for um botão de envio, este atributo booleano especifica que o formulário não deve ser
validado quando for enviado.

Se este atributo for especificado, ele substituirá o atributo novalidate do proprietário do formulário do botão.

func (*TagButton) FromAction 

func (e *TagButton) FromAction(action string) (ref *TagButton)

FromAction

English: 

The URL that processes the information submitted by the button. Overrides the action attribute of
the button's form owner. Does nothing if there is no form owner.

 Input:
   action: The URL that processes the form submission. This value can be overridden by a
           formaction attribute on a <button>, <input type="submit">, or <input type="image">
           element. This attribute is ignored when method="dialog" is set.

Português: 

A URL que processa as informações enviadas pelo botão. Substitui o atributo de ação do
proprietário do formulário do botão. Não faz nada se não houver um proprietário de formulário.

 Entrada:
   action: A URL que processa o envio do formulário. Esse valor pode ser substituído por um
           atributo formaction em um elemento <button>, <input type="submit"> ou
           <input type="image">. Este atributo é ignorado quando method="dialog" é definido.

func (*TagButton) GetX 

func (e *TagButton) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagButton) GetXY 

func (e *TagButton) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagButton) GetY 

func (e *TagButton) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagButton) Hidden 

func (e *TagButton) Hidden() (ref *TagButton)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagButton) Id 

func (e *TagButton) Id(id string) (ref *TagButton)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagButton) InputMode 

func (e *TagButton) InputMode(inputMode InputMode) (ref *TagButton)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagButton) Is 

func (e *TagButton) Is(is string) (ref *TagButton)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagButton) ItemDrop 

func (e *TagButton) ItemDrop(itemprop string) (ref *TagButton)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagButton) ItemId 

func (e *TagButton) ItemId(id string) (ref *TagButton)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagButton) ItemRef 

func (e *TagButton) ItemRef(itemref string) (ref *TagButton)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagButton) ItemType 

func (e *TagButton) ItemType(itemType string) (ref *TagButton)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagButton) Lang 

func (e *TagButton) Lang(language Language) (ref *TagButton)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagButton) Name 

func (e *TagButton) Name(name string) (ref *TagButton)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagButton) Nonce 

func (e *TagButton) Nonce(nonce int64) (ref *TagButton)

Nonce

English: 

A cryptographic nonce ("number used once") which can be used by Content Security Policy to
determine whether or not a given fetch will be allowed to proceed.

Português: 

Um nonce criptográfico ("número usado uma vez") que pode ser usado pela Política de Segurança de
Conteúdo para determinar se uma determinada busca terá permissão para prosseguir.

func (*TagButton) SetX 

func (e *TagButton) SetX(x int) (ref *TagButton)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagButton) SetXY 

func (e *TagButton) SetXY(x, y int) (ref *TagButton)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagButton) SetY 

func (e *TagButton) SetY(y int) (ref *TagButton)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagButton) Slot 

func (e *TagButton) Slot(slot string) (ref *TagButton)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagButton) Spellcheck 

func (e *TagButton) Spellcheck(spell bool) (ref *TagButton)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagButton) Style 

func (e *TagButton) Style(style string) (ref *TagButton)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagButton) TabIndex 

func (e *TagButton) TabIndex(index int) (ref *TagButton)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagButton) Title 

func (e *TagButton) Title(title string) (ref *TagButton)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagButton) Translate 

func (e *TagButton) Translate(translate Translate) (ref *TagButton)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagButton) Value 

func (e *TagButton) Value(value string) (ref *TagButton)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagCanvas 

type TagCanvas struct {
	// contains filtered or unexported fields
}

func (*TagCanvas) AddColorStopPosition 

func (el *TagCanvas) AddColorStopPosition(stopPosition float64, color color.RGBA) (ref *TagCanvas)

AddColorStopPosition

English: 

Specifies the colors and stop positions in a gradient object

   Input:
     stopPosition: A value between 0.0 and 1.0 that represents the position between start (0%) and
       end (100%) in a gradient;
     color: A color RGBA value to display at the stop position. You can use
       factoryColor.NewColorName() to make it easier;

 Note:
   * Before using this function, you need to generate a gradient with the CreateLinearGradient()
     or CreateRadialGradient() functions;
   * You can call the AddColorStopPosition() method multiple times to change a gradient. If you
     omit this method for gradient objects, the gradient will not be visible. You need to create
     at least one color stop to have a visible gradient.

 Example:

   	var fontA html.Font
   	fontA.Family = factoryFontFamily.NewArial()
   	fontA.Variant = factoryFontVariant.NewSmallCaps()
   	fontA.Style = factoryFontStyle.NewItalic()
   	fontA.Size = 20

   	var fontB html.Font
   	fontB.Family = factoryFontFamily.NewVerdana()
   	fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     AppendById("stage")

Português: 

Especifica a cor e a posição final para a cor dentro do gradiente
 Entrada:
   stopPosition: Um valor entre 0.0 e 1.0 que representa a posição entre o início (0%) e o fim
     (100%) dentro do gradiente;
   color: Uma cor no formato RGBA para ser mostrada na posição determinada. Você pode usar
     factoryColor.NewColorName() para facilitar.

 Nota:
   * Antes de usar esta função, você necessita gerar um gradiente com as funções
     CreateLinearGradient() ou CreateRadialGradient();
   * Você pode chamar o método AddColorStopPosition() várias vezes para adicionar várias cores ao
     gradiente, porém, se você omitir o método, o gradiente não será visível. Você tem à obrigação
     de chamar o método pelo menos uma vez com uma cor para que o gradiente seja visível.

 Exemplo:

   	var fontA html.Font
   	fontA.Family = factoryFontFamily.NewArial()
   	fontA.Variant = factoryFontVariant.NewSmallCaps()
   	fontA.Style = factoryFontStyle.NewItalic()
   	fontA.Size = 20

   	var fontB html.Font
   	fontB.Family = factoryFontFamily.NewVerdana()
   	fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     AppendById("stage")

func (*TagCanvas) Append 

func (el *TagCanvas) Append(append interface{}) (ref *TagCanvas)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagCanvas) AppendById 

func (el *TagCanvas) AppendById(appendId string) (ref *TagCanvas)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagCanvas) Arc 

func (el *TagCanvas) Arc(x, y int, radius, startAngle, endAngle float64, anticlockwise bool) (ref *TagCanvas)

Arc

English: 

Creates an arc/curve (used to create circles, or parts of circles).

 Input:
   x: The horizontal coordinate of the arc's center;
   y: The vertical coordinate of the arc's center;
   radius: The arc's radius. Must be positive;
   startAngle: The angle at which the arc starts in radians, measured from the positive x-axis;
   endAngle: The angle at which the arc ends in radians, measured from the positive x-axis;
   anticlockwise: An optional Boolean. If true, draws the arc counter-clockwise between the start
     and end angles. The default is false (clockwise).

   Example:

     factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
       BeginPath().
       Arc(100, 75, 50, 0, 2 * math.Pi, false).
       Stroke().
       AppendById("stage")

Português: 

Creates an arc/curve (used to create circles, or parts of circles).

 Input:
   x: A coordenada horizontal do centro do arco;
   y: A coordenada vertical do centro do arco;
   radius: O raio do arco. Deve ser positivo;
   startAngle: O ângulo no qual o arco começa em radianos, medido a partir do eixo x positivo;
   endAngle: O ângulo no qual o arco termina em radianos, medido a partir do eixo x positivo;
   anticlockwise: Um booleano opcional. Se true, desenha o arco no sentido anti-horário entre os
     ângulos inicial e final. O padrão é false (sentido horário).

   Example:

     factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
       BeginPath().
       Arc(100, 75, 50, 0, 2 * math.Pi, false).
       Stroke().
       AppendById("stage")

func (*TagCanvas) ArcTo 

func (el *TagCanvas) ArcTo(x1, y1, x2, y2 int, radius int) (ref *TagCanvas)

ArcTo

English: 

 Creates an arc/curve between two tangents.

  Input:
    x1: The x-axis coordinate of the first control point.
    y1: The y-axis coordinate of the first control point.
    x2: The x-axis coordinate of the second control point.
    y2: The y-axis coordinate of the second control point.
    radius: The arc's radius. Must be non-negative.

  Example:
    factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
      MoveTo(20, 20).
      LineTo(100, 20).
      ArcTo(150, 20, 150, 70, 50).
      LineTo(150, 120).
      Stroke().
		   AppendById("stage")

Português: 

 Cria um arco / curva entre duas tangentes.

  Input:
    x1: A coordenada do eixo x do primeiro ponto de controle;
    y1: A coordenada do eixo y do primeiro ponto de controle;
    x2: A coordenada do eixo x do segundo ponto de controle;
    y2: A coordenada do eixo y do segundo ponto de controle;
    radius: O raio do arco. Deve ser não negativo.

  Example:
    factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
      MoveTo(20, 20).
      LineTo(100, 20).
      ArcTo(150, 20, 150, 70, 50).
      LineTo(150, 120).
      Stroke().
		   AppendById("stage")

func (*TagCanvas) BeginPath 

func (el *TagCanvas) BeginPath() (ref *TagCanvas)

BeginPath

English: 

	Begins a path, or resets the current path

  Note:
    * Use MoveTo(), LineTo(), QuadricCurveTo(), BezierCurveTo(), ArcTo(), and Arc(), to
       create paths;
    * Use the Stroke() method to actually draw the path on the canvas.

Português: 

Inicia ou reinicializa uma nova rota no desenho

 Nota:
   * Dica: Use MoveTo(), LineTo(), QuadricCurveTo(), BezierCurveTo(), ArcTo(), e Arc(), para
     criar uma nova rota no desenho;
   * Use o método Stroke() para desenhar a rota no elemento canvas.

todo: fazer exemplo

func (*TagCanvas) BezierCurveTo 

func (el *TagCanvas) BezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y int) (ref *TagCanvas)

BezierCurveTo

English: 

Creates a cubic Bézier curve.

 Input:

   cp1x: The x-axis coordinate of the first control point;
   cp1y: The y-axis coordinate of the first control point;
   cp2x: The x-axis coordinate of the second control point;
   cp2y: The y-axis coordinate of the second control point;
   x: The x-axis coordinate of the end point;
   y: The y-axis coordinate of the end point.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     BezierCurveTo(20, 100, 200, 100, 200, 20).
     Stroke().
     AppendById("stage")

Português: 

Cria uma curva de Bézier cúbica.

 Entrada:

   cp1x: A coordenada do eixo x do primeiro ponto de controle;
   cp1y: A coordenada do eixo y do primeiro ponto de controle;
   cp2x: A coordenada do eixo x do segundo ponto de controle;
   cp2y: A coordenada do eixo y do segundo ponto de controle;
   x: A coordenada do eixo x do ponto final;
   y: A coordenada do eixo y do ponto final.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     BezierCurveTo(20, 100, 200, 100, 200, 20).
     Stroke().
     AppendById("stage")

func (*TagCanvas) ClearRect 

func (el *TagCanvas) ClearRect(x, y, width, height int) (ref *TagCanvas)

ClearRect

English: 

Clears the specified pixels within a given rectangle.
   x: The x-coordinate of the upper-left corner of the rectangle to clear
   y: The y-coordinate of the upper-left corner of the rectangle to clear
   width: The width of the rectangle to clear, in pixels
   height: The height of the rectangle to clear, in pixels

   The ClearRect() method clears the specified pixels within a given rectangle.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle("red").
     FillRect(0, 0, 300, 150).
     ClearRect(20, 20, 100, 50).
     AppendById("stage")

Português: 

Limpa os pixels especificados em um determinado retângulo.
   x: A coordenada x do canto superior esquerdo do retângulo para limpar;
   y: A coordenada y do canto superior esquerdo do retângulo para limpar;
   width: A largura do retângulo a ser limpo, em pixels;
   height: A altura do retângulo a ser limpo, em pixels.

   O método ClearRect() limpa os pixels especificados em um determinado retângulo.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle("red").
     FillRect(0, 0, 300, 150).
     ClearRect(20, 20, 100, 50).
     AppendById("stage")

func (*TagCanvas) Clip 

func (el *TagCanvas) Clip(x, y int) (ref *TagCanvas)

Clip

English: 

Clips a region of any shape and size from the original canvas.

The Clip() method clips a region of any shape and size from the original canvas. 

Note:
  * Once a region is clipped, all future drawing will be limited to the clipped region (no
    access to other regions on the canvas). You can however save the current canvas region using
    the Save() method before using the Clip() method, and restore it (with the Restore() method)
    any time in the future.

Português: 

Recorta uma região de qualquer forma e tamanho do canvas original.

O método Clip() recorta uma região de qualquer forma e tamanho do canvas original. 

Nota:
  * Uma vez recortada uma região, todos os desenhos futuros serão limitados à região recortada
    (sem acesso a outras regiões do canvas). No entanto, você pode salvar a região do canvas
    atual usando o método Save() antes de usar o método Clip() e restaurá-la, com o método
    Restore(), a qualquer momento no futuro.

todo: fazer exemplo

func (*TagCanvas) ClosePath 

func (el *TagCanvas) ClosePath(x, y int) (ref *TagCanvas)

ClosePath

English: 

Creates a path from the current point back to the starting point.

The ClosePath() method creates a path from the current point back to the starting point. 

Note:
  * Use the Stroke() method to actually draw the path on the canvas;
  * Use the Fill() method to fill the drawing, black is default. Use the FillStyle() function to
    fill with another color/gradient.

Português: 

Cria um caminho do ponto atual de volta ao ponto inicial.

O método ClosePath() cria um caminho do ponto atual de volta ao ponto inicial. 

Nota:
  * Use o método Stroke() para realmente desenhar o caminho no canvas;
  * Use o método Fill() para preencher o desenho, preto é o padrão. Use a função
    FillStyle() para preencher com outra cor / gradiente.

todo: fazer exemplo

func (*TagCanvas) CreateElement 

func (el *TagCanvas) CreateElement(tag Tag, width, height int) (ref *TagCanvas)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagCanvas) CreateLinearGradient 

func (el *TagCanvas) CreateLinearGradient(x0, y0, x1, y1 int) (ref *TagCanvas)

CreateLinearGradient

English: 

Creates a linear gradient.

 Input:
   x0: The x-coordinate of the start point of the gradient;
   y0: The y-coordinate of the start point of the gradient;
   x1: The x-coordinate of the end point of the gradient;
   y1: The y-coordinate of the end point of the gradient.

The CreateLinearGradient() method creates a linear gradient object.

The gradient can be used to fill rectangles, circles, lines, text, etc. 

Note:
  * Use this object as the value to the strokeStyle or fillStyle properties; //todo: rever documentação
  * Use the AddColorStopPosition() method to specify different colors, and where to position the
    colors in the gradient object.

Example:
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreateLinearGradient(0, 0, 170, 0).
    AddColorStopPosition(0.0, factoryColor.NewBlack()).
    AddColorStopPosition(0.5, factoryColor.NewOrangered()).
    AddColorStopPosition(1.0, factoryColor.NewWhite()).
    FillStyleGradient().
    FillRect(20, 20, 150, 100).
    AppendById("stage")

Português: 

Cria um gradiente linear.

 Entrada:
   x0: A coordenada x do ponto inicial do gradiente;
   y0: A coordenada y do ponto inicial do gradiente;
   x1: A coordenada x do ponto final do gradiente;
   y1: A coordenada y do ponto final do gradiente.

O método CreateLinearGradient() cria um objeto gradiente linear.

O gradiente pode ser usado para preencher retângulos, círculos, linhas, texto, etc. 

Nota:
  * Use esta objeto como o valor para as propriedades StrokeStyle() ou FillStyle(); //todo: rever documentação
  * Use o método AddColorStopPosition() para especificar cores diferentes e onde posicionar as
    cores no objeto gradiente.

Exemplo:
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreateLinearGradient(0, 0, 170, 0).
    AddColorStopPosition(0.0, factoryColor.NewBlack()).
    AddColorStopPosition(0.5, factoryColor.NewOrangered()).
    AddColorStopPosition(1.0, factoryColor.NewWhite()).
    FillStyleGradient().
    FillRect(20, 20, 150, 100).
    AppendById("stage")

func (*TagCanvas) CreatePattern 

func (el *TagCanvas) CreatePattern(image interface{}, repeatRule CanvasRepeatRule) (ref *TagCanvas)

CreatePattern

English: 

Repeats a specified element in the specified direction.

 Input:
   image: Specifies the image, canvas, or video element of the pattern to use
   repeatedElement
   repeatRule: Image repetition rule.
     KRepeatRuleRepeat: (Default) The pattern repeats both horizontally and vertically
     KRepeatRuleRepeatX: The pattern repeats only horizontally
     KRepeatRuleRepeatY: The pattern repeats only vertically
     KRepeatRuleNoRepeat: The pattern will be displayed only once (no repeat)

The CreatePattern() method repeats the specified element in the specified direction. The element can be an image, video, or another <canvas> element. The repeated element can be used to draw/fill rectangles, circles, lines etc. 

Example:

  var img = factoryBrowser.NewTagImage(
    "spacecraft",
    "./small.png",
    29,
    50,
    true,
  )
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreatePattern(img, html.KRepeatRuleRepeat).
    Rect(0, 0, 300, 300).
    FillStylePattern().
    Fill().
    AppendById("stage")

Português: 

Repete um elemento especificado na direção especificada.

 Entrada:
   image: Especifica a imagem, tela ou elemento de vídeo do padrão para usar repeatElement;
   repeatRule: Regra de repetição da imagem.
     KRepeatRuleRepeat: (Padrão) O padrão se repete horizontal e verticalmente;
     KRepeatRuleRepeatX: O padrão se repete apenas horizontalmente;
     KRepeatRuleRepeatY: O padrão se repete apenas verticalmente;
     KRepeatRuleNoRepeat: O padrão será exibido apenas uma vez (sem repetição).

O método CreatePattern() repete o elemento especificado na direção especificada.

O elemento pode ser uma imagem, vídeo ou outro elemento <canvas>.

O elemento repetido pode ser usado para desenhar retângulos, círculos, linhas etc. 

Exemplo:

  var img = factoryBrowser.NewTagImage(
    "spacecraft",
    "./small.png",
    29,
    50,
    true,
  )
  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    CreatePattern(img, html.KRepeatRuleRepeat).
    Rect(0, 0, 300, 300).
    FillStylePattern().
    Fill().
    AppendById("stage")

func (*TagCanvas) CreateRadialGradient 

func (el *TagCanvas) CreateRadialGradient(x0, y0, r0, x1, y1 int, r1 float64) (ref *TagCanvas)

CreateRadialGradient

English: 

Creates a radial/circular gradient (to use on canvas content)

 Input:
   x0: The x-coordinate of the starting circle of the gradient;
   y0: The y-coordinate of the starting circle of the gradient;
   r0: The radius of the starting circle;
   x1: The x-coordinate of the ending circle of the gradient;
   y1: The y-coordinate of the ending circle of the gradient;
   r1: The radius of the ending circle.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreateRadialGradient(75, 50, 5, 90, 60, 100).
     AddColorStopPosition(0.0, factoryColor.NewRed()).
     AddColorStopPosition(1.0, factoryColor.NewWhite()).
     FillStyleGradient().
     FillRect(10, 10, 150, 100).
     AppendById("stage")

Português: 

Cria um gradiente radial/circular (para usar no conteúdo do canvas)

 Entrada:
   x0: A coordenada x do círculo inicial do gradiente;
   y0: A coordenada y do círculo inicial do gradiente;
   r0: O raio do círculo inicial;
   x1: A coordenada x do círculo final do gradiente;
   y1: A coordenada y do círculo final do gradiente;
   r1: O raio do círculo final.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreateRadialGradient(75, 50, 5, 90, 60, 100).
     AddColorStopPosition(0.0, factoryColor.NewRed()).
     AddColorStopPosition(1.0, factoryColor.NewWhite()).
     FillStyleGradient().
     FillRect(10, 10, 150, 100).
     AppendById("stage")

func (*TagCanvas) DrawImage 

func (el *TagCanvas) DrawImage(image interface{}) (ref *TagCanvas)

DrawImage

English: 

Draws a preloaded image on the canvas element.

 Input:
   image: js.Value object with a preloaded image.

Português: 

Desenha uma imagem pre carregada no elemento canvas.

 Entrada:
   image: objeto js.Value com uma imagem pré carregada.

func (*TagCanvas) Fill 

func (el *TagCanvas) Fill() (ref *TagCanvas)

Fill

English: 

Fills the current drawing (path)

 Note:
   * The default color is black.
   * Use the FillStyle() function to fill with another color/gradient.
   * If the path is not closed, the Fill() method will add a line from the last point to the
     startpoint of the path to close the path (like ClosePath()), and then fill the path.

 Example:

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendById("stage")

Português: 

Preenche o desenho atual (caminho)

 Nota:
   * A cor padrão é preto.
   * Use a função FillStyle() para preencher com outro gradiente de cor.
   * Se o caminho não estiver fechado, o método Fill() adicionará uma linha do último ponto ao
     ponto inicial do caminho para fechar o caminho (como ClosePath()) e, em seguida, preencherá
     o caminho.

 Exemplo:

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendById("stage")

func (*TagCanvas) FillRect 

func (el *TagCanvas) FillRect(x, y, width, height int) (ref *TagCanvas)

FillRect

English: 

Draws a "filled" rectangle

 Input:
   x: The x-coordinate of the upper-left corner of the rectangle;
   y: The y-coordinate of the upper-left corner of the rectangle;
   width: The width of the rectangle, in pixels;
   height: The height of the rectangle, in pixels.

The FillRect() method draws a "filled" rectangle. The default color of the fill is black. 

Note:
  * Use the FillStyle() function to set a color, FillStyleGradient() to set a gradient or
    FillStylePattern() to set a pattern used to fill the drawing.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillRect(20, 20, 150, 100).
    AppendById("stage")

Português: 

Desenha um retângulo "preenchido"

 Entrada:
   x: A coordenada x do canto superior esquerdo do retângulo;
   y: A coordenada y do canto superior esquerdo do retângulo;
   width: A largura do retângulo, em pixels;
   height: A altura do retângulo, em pixels.

O método FillRect() desenha um retângulo "preenchido". A cor padrão do preenchimento é preto. 

Nota:
  * Use a função FillStyle() para definir uma cor, FillStyleGradient() para definir um gradiente
    ou FillStylePattern() para definir um padrão usado para preencher o desenho.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillRect(20, 20, 150, 100).
    AppendById("stage")

func (*TagCanvas) FillStyle 

func (el *TagCanvas) FillStyle(value interface{}) (ref *TagCanvas)

FillStyle

English: 

Sets the color, gradient, or pattern used to fill the drawing.

 Input:
   value: the color color.RGBA. You can use factoryColor.NewColorName() to make it easier;

 Note:
   * The default color is black.

Português: 

Define a cor, gradiente ou padrão usado para preencher o desenho.

 Entrada:
   value: a cor color.RGBA. Você pode usar factoryColor.NewColorName() para facilitar;

 Nota:
   * A cor padrão é preto.

func (*TagCanvas) FillStyleGradient 

func (el *TagCanvas) FillStyleGradient() (ref *TagCanvas)

FillStyleGradient

English: 

Sets javascript's fillStyle property after using CreateLinearGradient() or CreateRadialGradient()
functions.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendById("stage")

Português: 

Define a propriedade fillStyle do javascript depois de usar as funções CreateLinearGradient() ou
CreateRadialGradient().

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendById("stage")

func (*TagCanvas) FillStylePattern 

func (el *TagCanvas) FillStylePattern() (ref *TagCanvas)

FillStylePattern

English: 

Sets the javascript's fillStyle property after using the CreatePattern() function.

 Example

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendById("stage")

Português: 

Define a propriedade fillStyle do javascript após o uso da função CreatePattern().

 Exemplo:

   var img = factoryBrowser.NewTagImage(
     "spacecraft",
     "./small.png",
     29,
     50,
     true,
   )
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     CreatePattern(img, html.KRepeatRuleRepeat).
     Rect(0, 0, 300, 300).
     FillStylePattern().
     Fill().
     AppendById("stage")

func (*TagCanvas) FillText 

func (el *TagCanvas) FillText(text string, x, y, maxWidth int) (ref *TagCanvas)

FillText

English: 

Draws "filled" text on the canvas

 Input:
   text: Specifies the text that will be written on the canvas;
   x: The x coordinate where to start painting the text (relative to the canvas);
   y: The y coordinate where to start painting the text (relative to the canvas);
   maxWidth: Optional. The maximum allowed width of the text, in pixels.

The FillText() method draws filled text on the canvas. 

Note:
  * Use the Font() function to specify font and font size, and use the FillStyle() function to
    render the text in another color/gradient;
  * The default color of the text is black.

Example:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendById("stage")

Português: 

Desenha o texto "preenchido" no canvas.

 Entrada:
   text: Especifica o texto que será escrito no canvas;
   x: A coordenada x onde começar a pintar o texto (em relação ao canvas)
   y: A coordenada y onde começar a pintar o texto (em relação ao canvas)
   maxWidth: A largura máxima permitida do texto, em pixels.

O método FillText() desenha texto preenchido no canvas. 

Nota:
  * Use a função Font() para especificar a fonte e o tamanho da fonte e use a função FillStyle()
    para renderizar o texto em outra cor/gradiente;
  * A cor padrão do texto é preto.

Exemplo:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendById("stage")

func (*TagCanvas) Font 

func (el *TagCanvas) Font(font Font) (ref *TagCanvas)

Font

English: 

Sets the current font properties for text content.

  Input:
    font-style: Specifies the font style. Use the factory factoryFontStyle.
      E.g.: factoryFontStyle.NewItalic()
    font-variant: Specifies the font variant. Use the factory factoryFontVariant.
      E.g.: factoryFontVariant.NewSmallCaps()
    font-weight: Specifies the font weight. Use the factory factoryFontWeight.
      E.g.: factoryFontWeight.NewBold()
    font-size/line-height: Specifies the font size and the line-height in pixels
    font-family: Specifies the font family. Use the factory factoryFontFamily.
      E.g.: factoryFontFamily.NewArial()
    caption: Use the font captioned controls (like buttons, drop-downs, etc.)
    icon: Use the font used to label icons
    menu: Use the font used in menus (drop-down menus and menu lists)
    message-box: Use the font used in dialog boxes
    small-caption: Use the font used for labeling small controls
    status-bar: Use the fonts used in window status bar

The Font() function sets the current font properties for text content on the canvas.

Default value: 10px sans-serif 

Example:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendById("stage")

Português: 

Define as propriedades de fonte atuais para conteúdo de texto.

  Entrada:
    font-style: Especifica o estilo da fonte. Usar a fábrica factoryFontStyle.
      Ex.: factoryFontStyle.NewItalic()
    font-variant: Especifica a variante da fonte. Usar a fábrica factoryFontVariant.
      Ex.: factoryFontVariant.NewSmallCaps()
    font-weight: Especifica o peso da fonte. Usar a fábrica factoryFontWeight.
      Ex.: factoryFontWeight.NewBold()
    font-size/line-height: Especifica o tamanho da fonte e a altura da linha em pixels
    font-family: Especifica a família de fontes. Usar a fábrica factoryFontFamily.
      Ex.: factoryFontFamily.NewArial()
    caption: Use os controles legendados de fonte (como botões, menus suspensos etc.)
    icon: Use a fonte usada para rotular os ícones
    menu: Use a fonte usada nos menus (menus suspensos e listas de menus)
    message-box: Use a fonte usada nas caixas de diálogo
    small-caption: Use a fonte usada para rotular pequenos controles
    status-bar: Use as fontes usadas na barra de status da janela

A função Font() define ou retorna as propriedades de fonte atuais para conteúdo de texto no canvas

A propriedade font usa a mesma sintaxe que a propriedade font CSS.

Valor padrão: 10px sem serifa 

Exemplo:
  	var fontA html.Font
  	fontA.Family = factoryFontFamily.NewArial()
  	fontA.Style = factoryFontStyle.NewItalic()
  	fontA.Size = 20

  	var fontB html.Font
  	fontB.Family = factoryFontFamily.NewVerdana()
  	fontB.Size = 35

  	factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  	  Font(fontA).
  	  FillText("Hello World!", 10, 50, 300).
  	  CreateLinearGradient(0, 0, 160, 0).
  	  AddColorStopPosition(0.0, factoryColor.NewMagenta()).
  	  AddColorStopPosition(0.5, factoryColor.NewBlue()).
  	  AddColorStopPosition(1.0, factoryColor.NewRed()).
  	  FillStyleGradient().
  	  Font(fontB).
  	  FillText("Big smile!", 10, 90, 300).
  	  AppendById("stage")

func (*TagCanvas) GetCollisionData 

func (el *TagCanvas) GetCollisionData() (data [][]bool)

GetCollisionData

English: 

Returns an array (x,y) with a boolean indicating transparency.

The collision map is a quick way to preload data about the coordinates of where there are parts of the image. 

Output:
  data: [x][y]transparent

Português: 

Retorna uma array (x,y) com um booleano indicando transparência.

O mapa de colisão é uma forma rápida de deixar um dado pre carregado sobre as coordenadas de onde há partes da imagem. 

Saída:
  data: [x][y]transparente

todo: fazer exemplo

func (*TagCanvas) GetImageData 

func (el *TagCanvas) GetImageData(x, y, width, height int) (data [][][]uint8)

GetImageData

English: 

Returns an array copy of the image.

 Input:
   x: x position of the image;
   y: y position of the image;
   width: image width;
   height: image height.

 Output:
   data: image in matrix format.
     [x][y][0]: red color value between 0 and 255
     [x][y][1]: green color value between 0 and 255
     [x][y][2]: blue color value between 0 and 255
     [x][y][3]: alpha color value between 0 and 255

Português: 

Retorna uma cópia matricial da imagem.

 Entrada:
   x: Posição x da imagem;
   y: Posição y da imagem;
   width: comprimento da imagem;
   height: altura da imagem.

 Saída:
   data: imagem em formato matricial.
     [x][y][0]: valor da cor vermelha entre 0 e 255
     [x][y][1]: valor da cor verde entre 0 e 255
     [x][y][2]: valor da cor azul entre 0 e 255
     [x][y][3]: valor da cor alpha entre 0 e 255

todo: fazer exemplo

func (*TagCanvas) GlobalAlpha 

func (el *TagCanvas) GlobalAlpha(value float64) (ref *TagCanvas)

GlobalAlpha

English: 

Sets the current alpha or transparency value of the drawing
   value: The transparency value. Must be a number between 0.0 (fully transparent) and 1.0
     (no transparency)

   Default value: 1.0

 Example:
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewRed()).
     FillRect(20, 20, 75, 50).
     GlobalAlpha(0.2).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 75, 50).
     FillStyle(factoryColor.NewGreen()).
     FillRect(80, 80, 75, 50).
     AppendById("stage")

Português: 

Define o valor alfa ou transparência atual do desenho
   value: O valor da transparência. Deve ser um número entre 0.0 (totalmente transparente) e
     1.0 (sem transparência)

   Valor padrão: 1.0

 Exemplo:
   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewRed()).
     FillRect(20, 20, 75, 50).
     GlobalAlpha(0.2).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 75, 50).
     FillStyle(factoryColor.NewGreen()).
     FillRect(80, 80, 75, 50).
     AppendById("stage")

func (*TagCanvas) GlobalCompositeOperation 

func (el *TagCanvas) GlobalCompositeOperation(value CompositeOperationsRule) (ref *TagCanvas)

GlobalCompositeOperation

English: 

Sets how a new image are drawn onto an existing image

 Input:
   value: how a source (new) image are drawn onto a destination image.

The GlobalCompositeOperation() function sets how a source (new) image are drawn onto a destination (existing) image. 

Note:
  * source image = drawings you are about to place onto the canvas;
  * destination image = drawings that are already placed onto the canvas;
  * Default value: source-over.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewRed()).
    FillRect(20, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleSourceOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 75, 50).
    FillStyle(factoryColor.NewRed()).
    FillRect(150, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleDestinationOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(180, 50, 75, 50).
    AppendById("stage")

Português: 

Define como uma nova imagem é desenhada em uma imagem existente.

 Entrada:
   value: como uma imagem de origem (nova) é desenhada em uma imagem de destino.

A função GlobalCompositeOperation() define como uma imagem de origem (nova) é desenhada em uma imagem de destino (existente). 

Nota:
  * imagem de origem = desenhos que você está prestes a colocar no canvas;
  * imagem de destino = desenhos que já estão colocados no canvas;
  * Valor padrão: source-over.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewRed()).
    FillRect(20, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleSourceOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 75, 50).
    FillStyle(factoryColor.NewRed()).
    FillRect(150, 20, 75, 50).
    GlobalCompositeOperation(html.KCompositeOperationsRuleDestinationOver).
    FillStyle(factoryColor.NewBlue()).
    FillRect(180, 50, 75, 50).
    AppendById("stage")

func (*TagCanvas) Height 

func (el *TagCanvas) Height() (height int)

Height

English: 

Returns the height of an ImageData object.

 Output:
   height: returns the height of an ImageData object, in pixels.

Português: 

Retorna a altura de um objeto ImageData.

 Saída:
   height: retorna à altura de um objeto ImageData, em pixels.

func (*TagCanvas) Id 

func (el *TagCanvas) Id(id string) (ref *TagCanvas)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagCanvas) IsPointInPath 

func (el *TagCanvas) IsPointInPath(x, y int, fillRule FillRule) (isPointInPath bool)

IsPointInPath

English: 

Returns true if the specified point is in the current path, otherwise false

 Input:
   x: The x-axis coordinate of the point to check.
   y: The y-axis coordinate of the point to check.
   fillRule: The algorithm by which to determine if a point is inside or outside the path.
        "nonzero": The non-zero winding rule. Default rule.
        "evenodd": The even-odd winding rule.

 Example:

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     AppendById("stage")
     if canvas.IsPointInPath(20, 51, html.KFillRuleNonZero) {
       canvas.Stroke()
     }

Português: 

Retorna true se o ponto especificado estiver no caminho atual, caso contrário, false

 Entrada:
   x: A coordenada do eixo x do ponto a ser verificado.
   y: A coordenada do eixo y do ponto a ser verificado.
   fillRule: O algoritmo pelo qual determinar se um ponto está dentro ou fora do caminho.
        "nonzero": A regra de enrolamento diferente de zero. Regra padrão.
        "evenodd": A regra do enrolamento par-ímpar.

 Exemplo:

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     AppendById("stage")
     if canvas.IsPointInPath(20, 51, html.KFillRuleNonZero) {
       canvas.Stroke()
     }

func (*TagCanvas) LineCap 

func (el *TagCanvas) LineCap(value CapRule) (ref *TagCanvas)

LineCap

English:: 

Sets the style of the end caps for a line

 Input:
   PlatformBasicType: style of the end caps for a line

 Note:
   * The value "round" and "square" make the lines slightly longer.
   * Default value: butt

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineCap(html.KCapRuleRound).
     LineWidth(5).
     MoveTo(20, 20).
     LineTo(20, 200).
     Stroke().
     AppendById("stage")

Português:: 

Define o estilo das terminações de uma linha

 Entrada:
   PlatformBasicType: estilo das tampas de extremidade para uma linha

 Nota:
   * O valor "redondo" e "quadrado" tornam as linhas um pouco mais longas.
   * Valor padrão: butt

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineCap(html.KCapRuleRound).
     LineWidth(5).
     MoveTo(20, 20).
     LineTo(20, 200).
     Stroke().
     AppendById("stage")

func (*TagCanvas) LineJoin 

func (el *TagCanvas) LineJoin(value JoinRule) (ref *TagCanvas)

LineJoin

English: 

Sets the type of corner created, when two lines meet

 Input:
   PlatformBasicType: type of corner created

The LineJoin() function sets the type of corner created, when two lines meet. 

Note:
  * The KJoinRuleMiter value is affected by the MiterLimit() function.
  * Default value: miter

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendById("stage")

Português: 

Define o tipo de canto criado, quando duas linhas se encontram

 Entrada:
   PlatformBasicType: tipo de canto criado

A função LineJoin() define o tipo de canto criado, quando duas linhas se encontram. 

Nota:
  * O valor KJoinRuleMiter é afetado pela função MiterLimit().
  * Valor padrão: miter

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendById("stage")

func (*TagCanvas) LineTo 

func (el *TagCanvas) LineTo(x, y int) (ref *TagCanvas)

LineTo

English: 

Adds a new point and creates a line from that point to the last specified point in the canvas

 Input:
   x: The x-coordinate of where to create the line to
   y: The y-coordinate of where to create the line to

 Note:
   * This method does not draw the line.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendById("stage")

Português: 

Adiciona um novo ponto e cria uma linha desse ponto até o último ponto especificado no canvas

 Entrada:
   x: A coordenada x de onde criar a linha para
   y: A coordenada y de onde criar a linha para

 Nota:
   * Este método não desenha a linha.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendById("stage")

func (*TagCanvas) LineWidth 

func (el *TagCanvas) LineWidth(value int) (ref *TagCanvas)

LineWidth

English: 

Sets the current line width
   value: The current line width, in pixels

 Note:
   * Default value: 1

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendById("stage")

Português: 

Define a largura da linha atual
   value: A largura da linha atual, em pixels

 Nota:
   * Valor padrão: 1

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     LineWidth(5).
     LineJoin(html.KJoinRuleRound).
     MoveTo(20, 20).
     LineTo(100, 50).
     LineTo(20, 100).
     Stroke().
     AppendById("stage")

func (*TagCanvas) MeasureText 

func (el *TagCanvas) MeasureText(text string) (width int)

MeasureText

English: 

Returns an object that contains the width of the specified text

 Input:
   text: The text to be measured

 Example:

   var font html.Font
     font.Family = factoryFontFamily.NewArial()
     font.Size = 20

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(font)
     w := canvas.MeasureText("Hello Word!")
     wText := strconv.FormatInt(int64(w), 10)
     canvas.FillText("width:"+wText, 10, 50, 300).
     AppendById("stage")

Português: 

Retorna um objeto que contém a largura do texto especificado

 Entrada:
   text: O texto a ser medido

 Exemplo:

   var font html.Font
     font.Family = factoryFontFamily.NewArial()
     font.Size = 20

   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(font)
     w := canvas.MeasureText("Hello Word!")
     wText := strconv.FormatInt(int64(w), 10)
     canvas.FillText("width:"+wText, 10, 50, 300).
     AppendById("stage")

func (*TagCanvas) MiterLimit 

func (el *TagCanvas) MiterLimit(value int) (ref *TagCanvas)

MiterLimit

English: 

Sets the maximum miter length

 Input:
   value: A positive number that specifies the maximum miter length.

 Note:
   * If the current miter length exceeds the MiterLimit(), the corner will display as
     LineJoin(KJoinRuleBevel);
   * The miter length is the distance between the inner corner and the outer corner where two
     lines meet;
   * Default value: 10

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     LineWidth(10).
     LineJoin(html.KJoinRuleMiter).
     MiterLimit(5).
     MoveTo(20, 20).
     LineTo(50, 27).
     LineTo(20, 34).
     Stroke().
     AppendById("stage")

Português: 

Define ou retorna o comprimento máximo da mitra

 Entrada:
   value: Um número positivo que especifica o comprimento máximo da mitra.

 Nota:
   * Se o comprimento da mitra atual exceder o MiterLimit(), o canto será exibido como
     LineJoin(KJoinRuleBevel);
   * O comprimento da mitra é a distância entre o canto interno e o canto externo onde duas
     linhas se encontram;
   * Valor padrão: 10.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     LineWidth(10).
     LineJoin(html.KJoinRuleMiter).
     MiterLimit(5).
     MoveTo(20, 20).
     LineTo(50, 27).
     LineTo(20, 34).
     Stroke().
     AppendById("stage")

func (*TagCanvas) MoveTo 

func (el *TagCanvas) MoveTo(x, y int) (ref *TagCanvas)

MoveTo

English: 

Moves the path to the specified point in the canvas, without creating a line

 Input:
   x: The x-coordinate of where to move the path to
   y: The y-coordinate of where to move the path to

The MoveTo() function moves the path to the specified point in the canvas, without creating a line. 

Note:
  * Use the stroke() method to actually draw the path on the canvas.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendById("stage")

Português: 

Move o caminho para o ponto especificado no canvas, sem criar uma linha

 Entrada:
   x: A coordenada x de onde mover o caminho para
   y: A coordenada y de onde mover o caminho para

A função MoveTo() move o caminho para o ponto especificado no canvas, sem criar uma linha. 

Nota:
  * Use o método Stroke() para realmente desenhar o caminho no canvas.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    BeginPath().
    LineWidth(5).
    LineJoin(html.KJoinRuleRound).
    MoveTo(20, 20).
    LineTo(100, 50).
    LineTo(20, 100).
    Stroke().
    AppendById("stage")

func (*TagCanvas) PutImageData 

func (el *TagCanvas) PutImageData(imgData [][][]uint8, width, height int) (ref *TagCanvas)

PutImageData

English: 

Transform an array of data into an image.

 Input:
   imgData: data array with the new image;
     [x][y][0]: red color value between 0 and 255;
     [x][y][1]: green color value between 0 and 255;
     [x][y][2]: blue color value between 0 and 255;
     [x][y][3]: alpha color value between 0 and 255.
   width: image width;
   height: image height.

Português: 

Transforma uma matrix de dados em uma imagem.

 Entrada:
   imgData: array de dados com o a nova imagem;
     [x][y][0]: valor da cor vermelha entre 0 e 255;
     [x][y][1]: valor da cor verde entre 0 e 255;
     [x][y][2]: valor da cor azul entre 0 e 255;
     [x][y][3]: valor da cor alpha entre 0 e 255.
   width: comprimento da imagem;
   height: altura da imagem.

todo: fazer exemplo

func (*TagCanvas) QuadraticCurveTo 

func (el *TagCanvas) QuadraticCurveTo(cpx, cpy, x, y int) (ref *TagCanvas)

QuadraticCurveTo

English: 

Creates a quadratic Bézier curve.

 Input:
   cpx: The x-axis coordinate of the control point;
   cpy: The y-axis coordinate of the control point;
   x: The x-axis coordinate of the end point;
   y: The y-axis coordinate of the end point.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     QuadraticCurveTo(20, 100, 200, 20).
     Stroke().
     AppendById("stage")

Português: 

Cria uma curva Bézier quadrática.

 Entrada:
   cpx: A coordenada do eixo x do ponto de controle;
   cpy: A coordenada do eixo y do ponto de controle;
   x: A coordenada do eixo x do ponto final;
   y: A coordenada do eixo y do ponto final.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     BeginPath().
     MoveTo(20, 20).
     QuadraticCurveTo(20, 100, 200, 20).
     Stroke().
     AppendById("stage")

func (*TagCanvas) Rect 

func (el *TagCanvas) Rect(x, y, width, height int) (ref *TagCanvas)

Rect

English: 

Creates a rectangle.

 Input:
   x: The x-coordinate of the upper-left corner of the rectangle;
   y: The y-coordinate of the upper-left corner of the rectangle;
   width: The width of the rectangle, in pixels;
   height: The height of the rectangle, in pixels.

 Note:
   * Use the Stroke() or Fill() functions to actually draw the rectangle on the canvas.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     Stroke().
     AppendById("stage")

Português: 

Cria um retângulo.

 Entrada:
   x: A coordenada x do canto superior esquerdo do retângulo;
   y: A coordenada y do canto superior esquerdo do retângulo;
   width: A largura do retângulo, em pixels;
   height: A altura do retângulo, em pixels.

 Nota:
   * Use as funções Stroke() ou Fill() para realmente desenhar o retângulo no canvas.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(20, 20, 150, 100).
     Stroke().
     AppendById("stage")

func (*TagCanvas) Restore 

func (el *TagCanvas) Restore() (ref *TagCanvas)

Restore

English: 

Returns previously saved path state and attributes.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendById("stage")

Português: 

Retorna o estado e os atributos do caminho salvos anteriormente.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendById("stage")

func (*TagCanvas) Rotate 

func (el *TagCanvas) Rotate(angle float64) (ref *TagCanvas)

Rotate

English: 

Rotates the current drawing

 Input:
   angle: The rotation angle, in radians.

 Note:
   * To calculate from degrees to radians: degrees*math.Pi/180.
     Example: to rotate 5 degrees, specify the following: 5*math.Pi/180.
   * The rotation will only affect drawings made AFTER the rotation is done.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(50, 20, 150, 100).
     Stroke().
     Rotate(20*math.Pi/180).
     Rect(50, 20, 150, 100).
     Stroke().
     AppendById("stage")

Português: 

Gira o desenho atual.

 Entrada:
   angle: O ângulo de rotação, em radianos.

 Nota:
   * Para calcular de graus para radianos: graus*math.Pi/180.
     Exemplo: para girar 5 graus, especifique o seguinte: 5*math.Pi/180.
   * A rotação só afetará os desenhos feitos APÓS a rotação.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Rect(50, 20, 150, 100).
     Stroke().
     Rotate(20*math.Pi/180).
     Rect(50, 20, 150, 100).
     Stroke().
     AppendById("stage")

func (*TagCanvas) Save 

func (el *TagCanvas) Save() (ref *TagCanvas)

Save

English: 

Saves the state of the current context.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     FillText("Hello World!", 10, 50, 300).
     Save().
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     FillStyleGradient().
     Font(fontB).
     FillText("Big smile!", 10, 90, 300).
     Restore().
     FillText("Same font used before save", 10, 120, 300).
     AppendById("stage")

Português: 

Salva o estado do contexto atual.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    Font(fontA).
    FillText("Hello World!", 10, 50, 300).
    Save().
    CreateLinearGradient(0, 0, 160, 0).
    AddColorStopPosition(0.0, factoryColor.NewMagenta()).
    AddColorStopPosition(0.5, factoryColor.NewBlue()).
    AddColorStopPosition(1.0, factoryColor.NewRed()).
    FillStyleGradient().
    Font(fontB).
    FillText("Big smile!", 10, 90, 300).
    Restore().
    FillText("Same font used before save", 10, 120, 300).
    AppendById("stage")

func (*TagCanvas) Scale 

func (el *TagCanvas) Scale(scaleWidth, scaleHeight float64) (ref *TagCanvas)

Scale

English: 

Scales the current drawing bigger or smaller.

 Input:
   scaleWidth: Scales the width of the current drawing (1.0=100%, 0.5=50%, 2.0=200%, etc.)
   scaleHeight: Scales the height of the current drawing (1.0=100%, 0.5=50%, 2.0=200%, etc.)

 Note:
   * If you scale a drawing, all future drawings will also be scaled;
   * The positioning will also be scaled. If you scale(2.0,2.0); drawings will be positioned
     twice as far from the left and top of the canvas as you specify.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     Scale(2.0, 6.0).
     StrokeRect(5, 5, 25, 15).
     AppendById("stage")

Português: 

Dimensiona o desenho atual para maior ou menor.

 Entrada:
   scaleWidth: Dimensiona a largura do desenho atual (1.0=100%, 0.5=50%, 2.0=200%, etc.)
   scaleHeight: Dimensiona a altura do desenho atual (1.0=100%, 0.5=50%, 2.0=200%, etc.)

 Nota:
   * Se você dimensionar um desenho, todos os desenhos futuros também serão dimensionados;
   * O posicionamento também será dimensionado. Se você dimensionar (2.0, 2.0); os desenhos serão
     posicionados duas vezes mais distantes da esquerda e do topo do canvas conforme
     você especificar.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     Scale(2.0, 6.0).
     StrokeRect(5, 5, 25, 15).
     AppendById("stage")

func (*TagCanvas) SetTransform 

func (el *TagCanvas) SetTransform(a, b, c, d, e, f float64) (ref *TagCanvas)

SetTransform

English: 

Resets the current transform to the identity matrix.

 Input:
   a: Scales the drawings horizontally;
   b: Skews the drawings horizontally;
   c: Skews the drawings vertically;
   d: Scales the drawings vertically;
   e: Moves the the drawings horizontally;
   f: Moves the the drawings vertically.

 Note:
   * Each object on the canvas has a current transformation matrix.
     The SetTransform() function resets the current transform to the identity matrix, and then
     put transform data on GetLastTransform() function.
     In other words, the SetTransform() function lets you scale, rotate, move, and skew the
     current context.
   * The transformation will only affect drawings made after the SetTransform() function is
     called.
   * You can use the Save() and Restore() functions to archive the original transform parameters.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewYellow()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewRed()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 230, 70).
     AppendById("stage")

Português: 

Redefine a transformação atual para a matriz de identidade.

 Entrada:
   a: Dimensiona os desenhos horizontalmente;
   b: Inclina os desenhos horizontalmente;
   c: Inclina os desenhos verticalmente;
   d: Dimensiona os desenhos verticalmente;
   e: Move os desenhos horizontalmente;
   f: Move os desenhos verticalmente.

 Nota:
   * Cada objeto no canvas tem uma matriz de transformação atual.
     A função SetTransform() redefine a transformação atual para a matriz de identidade e, em
     seguida, coloca os dados de transformação na função GetLastTransform().
     Em outras palavras, o método SetTransform() permite dimensionar, girar, mover e inclinar o
     contexto atual.
   * A transformação só afetará os desenhos feitos após a chamada da função SetTransform().
   * Você pode usar as funções Save() e Restore() para arquivar os parâmetros de transform
     originais.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillStyle(factoryColor.NewYellow()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewRed()).
     FillRect(50, 50, 250, 100).
     SetTransform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
     FillStyle(factoryColor.NewBlue()).
     FillRect(50, 50, 230, 70).
     AppendById("stage")

func (*TagCanvas) Stroke 

func (el *TagCanvas) Stroke() (ref *TagCanvas)

Stroke

English: 

The Stroke() method actually draws the path you have defined with all those MoveTo() and
LineTo() methods.

The default color is black. 

Note:
  * Use the StrokeStyle() function to draw with another color/gradient.

Example:

factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  BeginPath().
  Arc(100, 75, 50, 0, 2 * math.Pi, false).
  Stroke().
  AppendById("stage")

Português: 

A função Stroke() na verdade desenha o caminho que você definiu com todos os métodos MoveTo()
e LineTo().

A cor padrão é preto. 

Nota:
  * Use a Função StrokeStyle() para desenhar com outra cor/gradiente

Exemplo:

factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
  BeginPath().
  Arc(100, 75, 50, 0, 2 * math.Pi, false).
  Stroke().
  AppendById("stage")

func (*TagCanvas) StrokeRect 

func (el *TagCanvas) StrokeRect(x, y, width, height int) (ref *TagCanvas)

StrokeRect

English: 

Draws a rectangle (no fill)

 Input:
   x: The x-coordinate of the upper-left corner of the rectangle;
   y: The y-coordinate of the upper-left corner of the rectangle;
   width: The width of the rectangle, in pixels;
   height: The height of the rectangle, in pixels;

 Note:
   * The default color of the stroke is black;
   * Use the StrokeStyle() function to set a color, CreateRadialGradient(), CreateLinearGradient()
     or CreatePattern() to style the stroke.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     AppendById("stage")

Português: 

Desenha um retângulo (sem preencher)

 entrada:
   x: A coordenada x do canto superior esquerdo do retângulo;
   y: A coordenada y do canto superior esquerdo do retângulo;
   width: A largura do retângulo, em pixels;
   height: A altura do retângulo, em pixels;

 Nota:
   * A cor padrão do traço é preto;
   * Use a função StrokeStyle() para definir uma cor, CreateRadialGradient(),
     CreateLinearGradient() ou CreatePattern() para estilizar o traço.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeRect(5, 5, 25, 15).
     AppendById("stage")

func (*TagCanvas) StrokeStyle 

func (el *TagCanvas) StrokeStyle(value interface{}) (ref *TagCanvas)

StrokeStyle

English: 

Sets the color, gradient, or pattern used for strokes.

 Input:
   value: The style must be the color name in textual form, such as "red" or "green", or a color.RGBA value.

 Note:
   * The default color is black.

 Example:

   var colorArc color.RGBA
   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600)
   for i := 0.0; i != 6.0; i += 1.0 {
     for j := 0.0; j != 6.0; j += 1.0 {
       colorArc.R = 0
       colorArc.G = uint8(255.0 - 42.5*i)
       colorArc.B = uint8(255.0 - 42.5*j)
       colorArc.A = 255
       canvas.StrokeStyle(colorArc).
         BeginPath().
         Arc(int(12.5+j*25.0), int(12.5+i*25.0), 10.0, 0.0, math.Pi*2.0, true).
         Stroke()
     }
   }
   canvas.AppendById("stage")

Português: 

Define a cor, gradiente ou padrão usado para traçados.

 Entrada:
   value: O estilo deve ser o nome da cor na forma textual, como "red" ou "green", ou um valor color.RGBA.

 Note:
   * A cor padrão é preta.

 Exemplo:

   var colorArc color.RGBA
   canvas := factoryBrowser.NewTagCanvas("canvas_0", 800, 600)
   for i := 0.0; i != 6.0; i += 1.0 {
     for j := 0.0; j != 6.0; j += 1.0 {
       colorArc.R = 0
       colorArc.G = uint8(255.0 - 42.5*i)
       colorArc.B = uint8(255.0 - 42.5*j)
       colorArc.A = 255
       canvas.StrokeStyle(colorArc).
         BeginPath().
         Arc(int(12.5+j*25.0), int(12.5+i*25.0), 10.0, 0.0, math.Pi*2.0, true).
         Stroke()
     }
   }
   canvas.AppendById("stage")

func (*TagCanvas) StrokeStyleGradient 

func (el *TagCanvas) StrokeStyleGradient() (ref *TagCanvas)

StrokeStyleGradient 

Sets javascript's strokeStyle property after using CreateLinearGradient() or
CreateRadialGradient() functions.

 Example:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendById("stage")

Português: 

Define a propriedade strokeStyle do javascript depois de usar as funções CreateLinearGradient()
ou CreateRadialGradient().

 Exemplo:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendById("stage")

func (*TagCanvas) StrokeText 

func (el *TagCanvas) StrokeText(text string, x, y, maxWidth int) (ref *TagCanvas)

StrokeText

English: 

Draws text on the canvas (no fill)

 Input:
   text: Specifies the text that will be written on the canvas
   x: The x coordinate where to start painting the text (relative to the canvas)
   y: The y coordinate where to start painting the text (relative to the canvas)
   maxWidth: The maximum allowed width of the text, in pixels

 Note:
   * The default color of the text is black.
   * Use the Font() function to specify font and font size, and use the StrokeStyle() function to
     render the text in another color/gradient.

 Example:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendById("stage")

Português: 

Desenha o texto no canvas (sem preenchimento)

 Entrada:
   text: Especifica o texto a ser desenhado no canvas;
   x: A coordenada X de onde iniciar a pintura do texto (relativa ao canvas)
   y: A coordenada Y de onde iniciar a pintura do texto (relativa ao canvas)
   maxWidth: A largura máxima permitida do texto, em pixels.

 Nota:
   * A cor padrão é preto.
   * Use a função Font() para especificar a fonte e o tamanho do texto, e use a função
     StrokeStyle() para renderizar o texto em outra cor/gradiente.

 Exemplo:

   var fontA html.Font
   fontA.Family = factoryFontFamily.NewArial()
   fontA.Style = factoryFontStyle.NewItalic()
   fontA.Size = 20

   var fontB html.Font
   fontB.Family = factoryFontFamily.NewVerdana()
   fontB.Size = 35

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     Font(fontA).
     StrokeText("Hello World!", 10, 50, 300).
     CreateLinearGradient(0, 0, 160, 0).
     AddColorStopPosition(0.0, factoryColor.NewMagenta()).
     AddColorStopPosition(0.5, factoryColor.NewBlue()).
     AddColorStopPosition(1.0, factoryColor.NewRed()).
     StrokeStyleGradient().
     Font(fontB).
     StrokeText("Big smile!", 10, 90, 300).
     AppendById("stage")

func (*TagCanvas) TextAlign 

func (el *TagCanvas) TextAlign(value FontAlignRule) (ref *TagCanvas)

TextAlign

English: 

Sets the current alignment for text content

 Input:
   value: the anchor point.

Normally, the text will START in the position specified, however, if you set TextAlign(html.KFontAlignRuleRight) and place the text in position 150, it means that the text should END in position 150. 

Note:
  * Use the FillText() or the StrokeText() function to actually draw and position the text on the canvas.
  * Default value: html.KFontAlignRuleStart

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    StrokeStyle(factoryColor.NewRed()).
    MoveTo(150, 20).
    LineTo(150, 170).
    Stroke().
    Font(font).
    TextAlign(html.KFontAlignRuleStart).
    FillText("textAlign = start", 150, 60, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleLeft).
    FillText("textAlign = left", 150, 100, 400).
    TextAlign(html.KFontAlignRuleCenter).
    FillText("textAlign = center", 150, 120, 400).
    TextAlign(html.KFontAlignRuleRight).
    FillText("textAlign = right", 150, 140, 400).
    AppendById("stage")

Português: 

Define o alinhamento atual do texto.

 Entrada:
   value: o ponto da âncora.

Normalmente, o texto COMEÇARÁ na posição especificada, no entanto, se você definir TextAlign(html.KFontAlignRuleRight) e colocar o texto na posição 150, significa que o texto deve TERMINAR na posição 150. 

NotA:
  * Use a função FillText() ou StrokeText() para realmente desenhar e posicionar o texto no
    canvas;
  * Valor padrão: html.KFontAlignRuleStart

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    StrokeStyle(factoryColor.NewRed()).
    MoveTo(150, 20).
    LineTo(150, 170).
    Stroke().
    Font(font).
    TextAlign(html.KFontAlignRuleStart).
    FillText("textAlign = start", 150, 60, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleEnd).
    FillText("textAlign = end", 150, 80, 400).
    TextAlign(html.KFontAlignRuleLeft).
    FillText("textAlign = left", 150, 100, 400).
    TextAlign(html.KFontAlignRuleCenter).
    FillText("textAlign = center", 150, 120, 400).
    TextAlign(html.KFontAlignRuleRight).
    FillText("textAlign = right", 150, 140, 400).
    AppendById("stage")

func (*TagCanvas) TextBaseline 

func (el *TagCanvas) TextBaseline(value TextBaseLineRule) (ref *TagCanvas)

TextBaseline

English: 

Sets the current text baseline used when drawing text.

 Input:
   PlatformBasicType: text baseline used when drawing text.

 Note:
   * The FillText() and StrokeText() functions will use the specified TextBaseline() value when positioning the text on the canvas.
   Default value: alphabetic

 Example:

   var font html.Font
   font.Family = factoryFontFamily.NewArial()
   font.Size = 20

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeStyle(factoryColor.NewRed()).
     MoveTo(5, 100).
     LineTo(395, 100).
     Stroke().
     Font(font).
     TextBaseline(html.KTextBaseLineRuleTop).
     FillText("Top", 5, 100, 300).
     TextBaseline(html.KTextBaseLineRuleBottom).
     FillText("Bottom", 50, 100, 300).
     TextBaseline(html.KTextBaseLineRuleMiddle).
     FillText("Middle", 120, 100, 300).
     TextBaseline(html.KTextBaseLineRuleAlphabetic).
     FillText("Alphabetic", 190, 100, 300).
     TextBaseline(html.KTextBaseLineRuleHanging).
     FillText("Hanging", 290, 100, 300).
     AppendById("stage")

Português: 

Define a linha de base usada para desenhar o texto.

 Entrada:
   PlatformBasicType: linha de base usada para desenhar o texto.

 Nota:
   * As funções FillText() e StrokeText() vão usar a linha de base especificada pela função TextBaseline() antes de posicionar o texto no canvas.
   * Valor padrão: html.KTextBaseLineRuleAlphabetic

 Exemplo:

   var font html.Font
   font.Family = factoryFontFamily.NewArial()
   font.Size = 20

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     StrokeStyle(factoryColor.NewRed()).
     MoveTo(5, 100).
     LineTo(395, 100).
     Stroke().
     Font(font).
     TextBaseline(html.KTextBaseLineRuleTop).
     FillText("Top", 5, 100, 300).
     TextBaseline(html.KTextBaseLineRuleBottom).
     FillText("Bottom", 50, 100, 300).
     TextBaseline(html.KTextBaseLineRuleMiddle).
     FillText("Middle", 120, 100, 300).
     TextBaseline(html.KTextBaseLineRuleAlphabetic).
     FillText("Alphabetic", 190, 100, 300).
     TextBaseline(html.KTextBaseLineRuleHanging).
     FillText("Hanging", 290, 100, 300).
     AppendById("stage")

func (*TagCanvas) Transform 

func (el *TagCanvas) Transform(a, b, c, d, e, f float64) (ref *TagCanvas)

Transform

English: 

Replaces the current transformation matrix for the drawing

 Input:
   a: Scales the drawing horizontally;
   b: Skew the the drawing horizontally;
   c: Skew the the drawing vertically;
   d: Scales the drawing vertically;
   e: Moves the the drawing horizontally;
   f: Moves the the drawing vertically.

Each object on the canvas has a current transformation matrix. The Transform() method replaces the current transformation matrix. It multiplies the current transformation matrix with the matrix described by: 

 a | c | e
---+---+---
 b | d | f
---+---+---
 0 | 0 | 1

In other words, the Transform() method lets you scale, rotate, move, and skew the current context. 

Note:
  * The transformation will only affect drawings made after the Transform() method is called;
  * The Transform() function behaves relatively to other transformations made by Rotate(),
    Scale(), Translate(), or Transform().
      Example: If you already have set your drawing to scale by two, and the Transform() method
      scales your drawings by two, your drawings will now scale by four.
  * Check out the SetTransform() method, which does not behave relatively to other
    transformations.
  * You can use the Save() and Restore() functions to archive the original transform parameters.

Example:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewYellow()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewRed()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 230, 70).
    AppendById("stage")

Português: 

Substitui a matriz de transformação atual para o desenho

 Entrada:
   a: Dimensiona o desenho horizontalmente;
   b: Inclinar o desenho horizontalmente;
   c: Inclinar o desenho verticalmente;
   d: Dimensiona o desenho verticalmente;
   e: Move o desenho horizontalmente;
   f: Move o desenho verticalmente.

Cada objeto no canvas tem uma matriz de transformação atual. O método Transform() substitui a matriz de transformação atual. Ele multiplica a matriz de transformação atual com a matriz descrita por: 

 a | c | e
---+---+---
 b | d | f
---+---+---
 0 | 0 | 1

Em outras palavras, o método Transform() permite dimensionar, girar, mover e inclinar o contexto atual. 

Nota:
  * A transformação só afetará os desenhos feitos depois que o método Transform() for chamado;
  * A função Transform() se comporta relativamente a outras transformações feitas por Rotate(),
    Scale(), Translate() ou Transform().
    Exemplo: Se você já configurou seu desenho para dimensionar em dois, e o método Transform()
      dimensiona seus desenhos em dois, seus desenhos agora serão dimensionados em quatro.
  * Confira o método SetTransform(), que não se comporta em relação a outras transformações.
  * Você pode usar as funções Save() e Restore() para arquivar os parâmetros de transform
    originais.

Exemplo:

  factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
    FillStyle(factoryColor.NewYellow()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewRed()).
    FillRect(50, 50, 250, 100).
    Transform(1.0, 0.5, -0.5, 1.0, 30.0, 10.0).
    FillStyle(factoryColor.NewBlue()).
    FillRect(50, 50, 230, 70).
    AppendById("stage")

func (*TagCanvas) Translate 

func (el *TagCanvas) Translate(x, y int) (ref *TagCanvas)

Translate

English: 

Remaps the (0,0) position on the canvas

 Input:
   x: The value to add to horizontal (x) coordinates;
   y: The value to add to vertical (y) coordinates.

 Note:
   * When you call a method like FillRect() after Translate(), the value is added to the x and y
     coordinate values for all new canvas elements.

 Example:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillRect(10, 10, 100, 50).
     Translate(70, 70).
     FillRect(10, 10, 100, 50).
     AppendById("stage")

Português: 

Remapeia a posição (0,0) no canvas

 Entrada:
   x: O valor a ser adicionado às coordenadas horizontais (x);
   y: O valor a ser adicionado às coordenadas verticais (y).

 Nota:
   * Quando você chama um método como FillRect() após Translate(), o valor é adicionado aos
     valores das coordenadas x e y para todos os novos elementos do canvas.

 Exemplo:

   factoryBrowser.NewTagCanvas("canvas_0", 800, 600).
     FillRect(10, 10, 100, 50).
     Translate(70, 70).
     FillRect(10, 10, 100, 50).
     AppendById("stage")

type TagDataList 

type TagDataList struct {
	// contains filtered or unexported fields
}

TagDataList

English: 

The <datalist> HTML element contains a set of <option> elements that represent the permissible
or recommended options available to choose from within other controls.

Português 

O elemento HTML <datalist> contém um conjunto de elementos <option> que representam as opções
permitidas ou recomendadas disponíveis para escolha em outros controles.

func (*TagDataList) AccessKey 

func (e *TagDataList) AccessKey(key string) (ref *TagDataList)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagDataList) Append 

func (e *TagDataList) Append(append interface{}) (ref *TagDataList)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDataList) AppendById 

func (e *TagDataList) AppendById(appendId string) (ref *TagDataList)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDataList) Autofocus 

func (e *TagDataList) Autofocus(autofocus bool) (ref *TagDataList)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagDataList) Class 

func (e *TagDataList) Class(class ...string) (ref *TagDataList)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

func (*TagDataList) ContentEditable 

func (e *TagDataList) ContentEditable(editable bool) (ref *TagDataList)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagDataList) CreateElement 

func (e *TagDataList) CreateElement(tag Tag) (ref *TagDataList)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagDataList) Data 

func (e *TagDataList) Data(data map[string]string) (ref *TagDataList)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagDataList) Dir 

func (e *TagDataList) Dir(dir Dir) (ref *TagDataList)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagDataList) Draggable 

func (e *TagDataList) Draggable(draggable Draggable) (ref *TagDataList)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagDataList) EnterKeyHint 

func (e *TagDataList) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagDataList)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagDataList) GetX 

func (e *TagDataList) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagDataList) GetXY 

func (e *TagDataList) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagDataList) GetY 

func (e *TagDataList) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagDataList) Hidden 

func (e *TagDataList) Hidden() (ref *TagDataList)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagDataList) Id 

func (e *TagDataList) Id(id string) (ref *TagDataList)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagDataList) InputMode 

func (e *TagDataList) InputMode(inputMode InputMode) (ref *TagDataList)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagDataList) Is 

func (e *TagDataList) Is(is string) (ref *TagDataList)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagDataList) ItemDrop 

func (e *TagDataList) ItemDrop(itemprop string) (ref *TagDataList)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagDataList) ItemId 

func (e *TagDataList) ItemId(id string) (ref *TagDataList)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagDataList) ItemRef 

func (e *TagDataList) ItemRef(itemref string) (ref *TagDataList)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagDataList) ItemType 

func (e *TagDataList) ItemType(itemType string) (ref *TagDataList)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagDataList) Lang 

func (e *TagDataList) Lang(language Language) (ref *TagDataList)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagDataList) NewOption 

func (e *TagDataList) NewOption(id, label, value string, disabled, selected bool) (ref *TagDataList)

NewOption

English: 

The <option> HTML element is used to define an item contained in a <select>, an <optgroup>, or
a <datalist> element. As such, <option> can represent menu items in popups and other lists of
items in an HTML document.

 Input:
   id: a unique id for an element;
   label: This attribute is text for the label indicating the meaning of the option. If the label
     attribute isn't defined, its value is that of the element text content;
   value: The content of this attribute represents the value to be submitted with the form, should
     this option be selected. If this attribute is omitted, the value is taken from the text
     content of the option element;
   disabled: If this Boolean attribute is set, this option is not checkable. Often browsers grey
     out such control and it won't receive any browsing event, like mouse clicks or focus-related
     ones. If this attribute is not set, the element can still be disabled if one of its ancestors
     is a disabled <optgroup> element;
   selected: If present, this Boolean attribute indicates that the option is initially selected.
     If the <option> element is the descendant of a <select> element whose multiple attribute is
     not set, only one single <option> of this <select> element may have the selected attribute.

Português: 

O elemento HTML <option> é usado para definir um item contido em um elemento <select>, <optgroup>
ou <datalist>. Como tal, <option> pode representar itens de menu em pop-ups e outras listas de
itens em um documento HTML.

 Entrada:
   id: um id exclusivo para um elemento;
   label: Este atributo é um texto para o rótulo que indica o significado da opção. Se o atributo
     label não estiver definido, seu valor será o do conteúdo do texto do elemento;
   value: O conteúdo deste atributo representa o valor a ser enviado com o formulário, caso esta
     opção seja selecionada. Se este atributo for omitido, o valor será obtido do conteúdo de
     texto do elemento de opção;
   disabled: Se este atributo booleano estiver definido, esta opção não poderá ser marcada.
     Muitas vezes, os navegadores desativam esse controle e não recebem nenhum evento de
     navegação, como cliques do mouse ou relacionados ao foco. Se este atributo não for definido,
     o elemento ainda poderá ser desabilitado se um de seus ancestrais for um elemento <optgroup>
     desabilitado;
   selected: Se presente, este atributo booleano indica que a opção foi selecionada inicialmente.
     Se o elemento <option> é descendente de um elemento <select> cujo atributo múltiplo não está
     definido, apenas um único <option> deste elemento <select> pode ter o atributo selecionado.

func (*TagDataList) Nonce 

func (e *TagDataList) Nonce(nonce int64) (ref *TagDataList)

Nonce

English: 

A cryptographic nonce ("number used once") which can be used by Content Security Policy to
determine whether or not a given fetch will be allowed to proceed.

Português: 

Um nonce criptográfico ("número usado uma vez") que pode ser usado pela Política de Segurança de
Conteúdo para determinar se uma determinada busca terá permissão para prosseguir.

func (*TagDataList) SetX 

func (e *TagDataList) SetX(x int) (ref *TagDataList)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagDataList) SetXY 

func (e *TagDataList) SetXY(x, y int) (ref *TagDataList)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagDataList) SetY 

func (e *TagDataList) SetY(y int) (ref *TagDataList)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagDataList) Slot 

func (e *TagDataList) Slot(slot string) (ref *TagDataList)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagDataList) Spellcheck 

func (e *TagDataList) Spellcheck(spell bool) (ref *TagDataList)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagDataList) Style 

func (e *TagDataList) Style(style string) (ref *TagDataList)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDataList) TabIndex 

func (e *TagDataList) TabIndex(index int) (ref *TagDataList)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDataList) Title 

func (e *TagDataList) Title(title string) (ref *TagDataList)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDataList) Translate 

func (e *TagDataList) Translate(translate Translate) (ref *TagDataList)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagDiv 

type TagDiv struct {
	// contains filtered or unexported fields
}

TagDiv

English: 

The <div> tag defines a division or a section in an HTML document.

 Note:
   * By default, browsers always place a line break before and after the <div> element;
   * The <div> tag is used as a container for HTML elements - which is then styled with CSS or
     manipulated with JavaScript;
   * The <div> tag is easily styled by using the class or id attribute;
   * Any sort of content can be put inside the <div> tag.

Português: 

A tag <div> define uma divisão ou uma seção em um documento HTML.

 Nota:
   * Por padrão, os navegadores sempre colocam uma quebra de linha antes e depois do elemento
     <div>;
   * A tag <div> é usada como um contêiner para elementos HTML - que são estilizados com CSS ou
     manipulados com JavaScript
   * A tag <div> é facilmente estilizada usando o atributo class ou id;
   * Qualquer tipo de conteúdo pode ser colocado dentro da tag <div>.

func (*TagDiv) AccessKey 

func (e *TagDiv) AccessKey(key string) (ref *TagDiv)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagDiv) AddListener 

func (e *TagDiv) AddListener(eventType interface{}, manager mouse.SimpleManager) (ref *TagDiv)

AddListener

English: 

Associates a function with an event.

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Associa uma função a um evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagDiv) Append 

func (e *TagDiv) Append(append interface{}) (ref *TagDiv)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDiv) AppendById 

func (e *TagDiv) AppendById(appendId string) (ref *TagDiv)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagDiv) Autofocus 

func (e *TagDiv) Autofocus(autofocus bool) (ref *TagDiv)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagDiv) Class 

func (e *TagDiv) Class(class ...string) (ref *TagDiv)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagDiv) ContentEditable 

func (e *TagDiv) ContentEditable(editable bool) (ref *TagDiv)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagDiv) CreateElement 

func (e *TagDiv) CreateElement(tag Tag) (ref *TagDiv)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagDiv) Data 

func (e *TagDiv) Data(data map[string]string) (ref *TagDiv)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagDiv) Dir 

func (e *TagDiv) Dir(dir Dir) (ref *TagDiv)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagDiv) DragStart 

func (e *TagDiv) DragStart() (ref *TagDiv)

DragStart

English: 

Adiciona a função de arrastar com o mouse.

Português: 

Adiciona a função de arrastar com o mouse.

todo: tem que haver outro tipo de drag

func (*TagDiv) DragStop 

func (e *TagDiv) DragStop() (ref *TagDiv)

func (*TagDiv) Draggable 

func (e *TagDiv) Draggable(draggable Draggable) (ref *TagDiv)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagDiv) EnterKeyHint 

func (e *TagDiv) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagDiv)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagDiv) GetX 

func (e *TagDiv) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagDiv) GetXY 

func (e *TagDiv) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagDiv) GetY 

func (e *TagDiv) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagDiv) Hidden 

func (e *TagDiv) Hidden() (ref *TagDiv)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagDiv) Id 

func (e *TagDiv) Id(id string) (ref *TagDiv)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagDiv) Init 

func (e *TagDiv) Init(id string)

Init

English: 

Initializes the object correctly.

Português: 

Inicializa o objeto corretamente.

func (*TagDiv) InputMode 

func (e *TagDiv) InputMode(inputMode InputMode) (ref *TagDiv)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagDiv) Is 

func (e *TagDiv) Is(is string) (ref *TagDiv)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagDiv) ItemDrop 

func (e *TagDiv) ItemDrop(itemprop string) (ref *TagDiv)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagDiv) ItemId 

func (e *TagDiv) ItemId(id string) (ref *TagDiv)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagDiv) ItemRef 

func (e *TagDiv) ItemRef(itemref string) (ref *TagDiv)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagDiv) ItemType 

func (e *TagDiv) ItemType(itemType string) (ref *TagDiv)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagDiv) Lang 

func (e *TagDiv) Lang(language Language) (ref *TagDiv)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagDiv) Mouse 

func (e *TagDiv) Mouse(value mouse.CursorType) (ref *TagDiv)

Mouse

English: 

Defines the shape of the mouse pointer.

 Input:
   value: mouse pointer shape.
     Example: SetMouse(mouse.KCursorCell) // Use mouse.K... and let autocomplete do the
              rest

Português: 

Define o formato do ponteiro do mouse.

 Entrada:
   value: formato do ponteiro do mouse.
     Exemplo: SetMouse(mouse.KCursorCell) // Use mouse.K... e deixe o autocompletar fazer
              o resto

func (*TagDiv) Nonce 

func (e *TagDiv) Nonce(part ...string) (ref *TagDiv)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagDiv) RemoveListener 

func (e *TagDiv) RemoveListener(eventType interface{}) (ref *TagDiv)

RemoveListener

English: 

Remove the function associated with the event

 Example:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

Português: 

Remove a função associada com o evento.

 Exemplo:

   stage.AddListener(browserMouse.KEventMouseOver, onMouseEvent)
   timer := time.NewTimer(10 * time.Second)
   go func() {
     select {
       case <-timer.C:
       stage.RemoveListener(mouse.KEventMouseOver)
     }
   }()

   func onMouseEvent(event browserMouse.MouseEvent) {
     isNull, target := event.GetRelatedTarget()
     if isNull == false {
       log.Print("id: ", target.Get("id"))
       log.Print("tagName: ", target.Get("tagName"))
     }
     log.Print(event.GetScreenX())
     log.Print(event.GetScreenY())
   }

func (*TagDiv) SetX 

func (e *TagDiv) SetX(x int) (ref *TagDiv)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagDiv) SetXY 

func (e *TagDiv) SetXY(x, y int) (ref *TagDiv)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagDiv) SetY 

func (e *TagDiv) SetY(y int) (ref *TagDiv)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagDiv) Slot 

func (e *TagDiv) Slot(slot string) (ref *TagDiv)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagDiv) Spellcheck 

func (e *TagDiv) Spellcheck(spell bool) (ref *TagDiv)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagDiv) Style 

func (e *TagDiv) Style(style string) (ref *TagDiv)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDiv) TabIndex 

func (e *TagDiv) TabIndex(index int) (ref *TagDiv)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDiv) Title 

func (e *TagDiv) Title(title string) (ref *TagDiv)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagDiv) Translate 

func (e *TagDiv) Translate(translate Translate) (ref *TagDiv)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagFieldset 

type TagFieldset struct {
	// contains filtered or unexported fields
}

func (*TagFieldset) AccessKey 

func (e *TagFieldset) AccessKey(key string) (ref *TagFieldset)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagFieldset) Append 

func (e *TagFieldset) Append(append interface{}) (ref *TagFieldset)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagFieldset) AppendById 

func (e *TagFieldset) AppendById(appendId string) (ref *TagFieldset)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagFieldset) Autofocus 

func (e *TagFieldset) Autofocus(autofocus bool) (ref *TagFieldset)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagFieldset) Class 

func (e *TagFieldset) Class(class ...string) (ref *TagFieldset)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

func (*TagFieldset) ContentEditable 

func (e *TagFieldset) ContentEditable(editable bool) (ref *TagFieldset)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagFieldset) CreateElement 

func (e *TagFieldset) CreateElement(tag Tag) (ref *TagFieldset)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagFieldset) Data 

func (e *TagFieldset) Data(data map[string]string) (ref *TagFieldset)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagFieldset) Dir 

func (e *TagFieldset) Dir(dir Dir) (ref *TagFieldset)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagFieldset) Disabled 

func (e *TagFieldset) Disabled(disabled bool) (ref *TagFieldset)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagFieldset) Draggable 

func (e *TagFieldset) Draggable(draggable Draggable) (ref *TagFieldset)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagFieldset) EnterKeyHint 

func (e *TagFieldset) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagFieldset)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagFieldset) Form 

func (e *TagFieldset) Form(form string) (ref *TagFieldset)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagFieldset) GetX 

func (e *TagFieldset) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagFieldset) GetXY 

func (e *TagFieldset) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagFieldset) GetY 

func (e *TagFieldset) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagFieldset) Hidden 

func (e *TagFieldset) Hidden() (ref *TagFieldset)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagFieldset) Id 

func (e *TagFieldset) Id(id string) (ref *TagFieldset)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagFieldset) InputMode 

func (e *TagFieldset) InputMode(inputMode InputMode) (ref *TagFieldset)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagFieldset) Is 

func (e *TagFieldset) Is(is string) (ref *TagFieldset)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagFieldset) ItemDrop 

func (e *TagFieldset) ItemDrop(itemprop string) (ref *TagFieldset)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagFieldset) ItemId 

func (e *TagFieldset) ItemId(id string) (ref *TagFieldset)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagFieldset) ItemRef 

func (e *TagFieldset) ItemRef(itemref string) (ref *TagFieldset)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagFieldset) ItemType 

func (e *TagFieldset) ItemType(itemType string) (ref *TagFieldset)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagFieldset) Lang 

func (e *TagFieldset) Lang(language Language) (ref *TagFieldset)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagFieldset) Name 

func (e *TagFieldset) Name(name string) (ref *TagFieldset)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagFieldset) Nonce 

func (e *TagFieldset) Nonce(part ...string) (ref *TagFieldset)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagFieldset) SetX 

func (e *TagFieldset) SetX(x int) (ref *TagFieldset)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagFieldset) SetXY 

func (e *TagFieldset) SetXY(x, y int) (ref *TagFieldset)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagFieldset) SetY 

func (e *TagFieldset) SetY(y int) (ref *TagFieldset)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagFieldset) Slot 

func (e *TagFieldset) Slot(slot string) (ref *TagFieldset)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagFieldset) Spellcheck 

func (e *TagFieldset) Spellcheck(spell bool) (ref *TagFieldset)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagFieldset) Style 

func (e *TagFieldset) Style(style string) (ref *TagFieldset)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFieldset) TabIndex 

func (e *TagFieldset) TabIndex(index int) (ref *TagFieldset)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFieldset) Title 

func (e *TagFieldset) Title(title string) (ref *TagFieldset)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagFieldset) Translate 

func (e *TagFieldset) Translate(translate Translate) (ref *TagFieldset)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagForm 

type TagForm struct {
	// contains filtered or unexported fields
}

func (*TagForm) AccessKey 

func (e *TagForm) AccessKey(key string) (ref *TagForm)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagForm) Action 

func (e *TagForm) Action(action string) (ref *TagForm)

Action

English: 

The URL that processes the form submission. This value can be overridden by a formaction
attribute on a <button>, <input type="submit">, or <input type="image"> element.

This attribute is ignored when method="dialog" is set.

Português: 

A URL que processa o envio do formulário. Esse valor pode ser substituído por um atributo
formaction em um elemento <button>, <input type="submit"> ou <input type="image">.

Este atributo é ignorado quando method="dialog" é definido.

func (*TagForm) Append 

func (e *TagForm) Append(append interface{}) (ref *TagForm)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagForm) AppendById 

func (e *TagForm) AppendById(appendId string) (ref *TagForm)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagForm) Autocomplete 

func (e *TagForm) Autocomplete(autocomplete Autocomplete) (ref *TagForm)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagForm) Autofocus 

func (e *TagForm) Autofocus(autofocus bool) (ref *TagForm)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagForm) Charset 

func (e *TagForm) Charset(value string) (ref *TagForm)

Charset

English: 

Space-separated character encodings the server accepts. The browser uses them in the order in
which they are listed. The default value means the same encoding as the page.
(In previous versions of HTML, character encodings could also be delimited by commas.)

Português: 

Codificações de caracteres separados por espaço que o servidor aceita. O navegador os utiliza na
ordem em que estão listados. O valor padrão significa a mesma codificação da página.
(Nas versões anteriores do HTML, as codificações de caracteres também podiam ser delimitadas
por vírgulas.)

func (*TagForm) Class 

func (e *TagForm) Class(class ...string) (ref *TagForm)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagForm) ContentEditable 

func (e *TagForm) ContentEditable(editable bool) (ref *TagForm)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagForm) CreateElement 

func (e *TagForm) CreateElement(tag Tag) (ref *TagForm)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagForm) Data 

func (e *TagForm) Data(data map[string]string) (ref *TagForm)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagForm) Dir 

func (e *TagForm) Dir(dir Dir) (ref *TagForm)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagForm) Draggable 

func (e *TagForm) Draggable(draggable Draggable) (ref *TagForm)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagForm) EncType 

func (e *TagForm) EncType(formenctype FormEncType) (ref *TagForm)

EncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagForm) EnterKeyHint 

func (e *TagForm) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagForm)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagForm) GetX 

func (e *TagForm) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagForm) GetXY 

func (e *TagForm) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagForm) GetY 

func (e *TagForm) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagForm) Hidden 

func (e *TagForm) Hidden() (ref *TagForm)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagForm) Id 

func (e *TagForm) Id(id string) (ref *TagForm)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagForm) InputMode 

func (e *TagForm) InputMode(inputMode InputMode) (ref *TagForm)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagForm) Is 

func (e *TagForm) Is(is string) (ref *TagForm)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagForm) ItemDrop 

func (e *TagForm) ItemDrop(itemprop string) (ref *TagForm)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagForm) ItemId 

func (e *TagForm) ItemId(id string) (ref *TagForm)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagForm) ItemRef 

func (e *TagForm) ItemRef(itemref string) (ref *TagForm)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagForm) ItemType 

func (e *TagForm) ItemType(itemType string) (ref *TagForm)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagForm) Lang 

func (e *TagForm) Lang(language Language) (ref *TagForm)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagForm) Method 

func (e *TagForm) Method(method FormMethod) (ref *TagForm)

Method

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials;
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms;
     KFormMethodDialog: When the form is inside a <dialog>, closes the dialog and throws a submit
       event on submission without submitting data or clearing the form.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login;
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa;
     KFormMethodDialog: Quando o formulário está dentro de um <dialog>, fecha o diálogo e lança um
       evento submit no envio sem enviar dados ou limpar o formulário.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagForm) Name 

func (e *TagForm) Name(name string) (ref *TagForm)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagForm) Nonce 

func (e *TagForm) Nonce(part ...string) (ref *TagForm)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagForm) Novalidate 

func (e *TagForm) Novalidate(novalidate string) (ref *TagForm)

Novalidate

English: 

This Boolean attribute indicates that the form shouldn't be validated when submitted.

If this attribute is not set (and therefore the form is validated), it can be overridden by a formnovalidate attribute on a <button>, <input type="submit">, or <input type="image"> element belonging to the form.

Português: 

Este atributo booleano indica que o formulário não deve ser validado quando enviado.

Se este atributo não estiver definido (e, portanto, o formulário for validado), ele poderá ser substituído por um atributo formnovalidate em um elemento <button>, <input type="submit"> ou <input type="image"> pertencente a a forma.

func (*TagForm) Rel 

func (e *TagForm) Rel(rel string) (ref *TagForm)

Rel

English: 

The relationship of the linked URL as space-separated link types.

Português: 

O relacionamento da URL vinculada como tipos de link separados por espaço.

func (*TagForm) SetX 

func (e *TagForm) SetX(x int) (ref *TagForm)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagForm) SetXY 

func (e *TagForm) SetXY(x, y int) (ref *TagForm)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagForm) SetY 

func (e *TagForm) SetY(y int) (ref *TagForm)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagForm) Slot 

func (e *TagForm) Slot(slot string) (ref *TagForm)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagForm) Spellcheck 

func (e *TagForm) Spellcheck(spell bool) (ref *TagForm)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagForm) Style 

func (e *TagForm) Style(style string) (ref *TagForm)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagForm) TabIndex 

func (e *TagForm) TabIndex(index int) (ref *TagForm)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagForm) Target 

func (e *TagForm) Target(target Target) (ref *TagForm)

Target

English:

Where to display the linked URL, as the name for a browsing context (a tab, window, or <iframe>). The following keywords have special meanings for where to load the URL: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Note:
  * Setting KTargetBlank on <a> elements implicitly provides the same rel behavior as setting
    rel="noopener" which does not set window.opener. See browser compatibility for support
    status.

Português:

Onde exibir a URL vinculada, como o nome de um contexto de navegação (uma guia, janela ou <iframe>). As seguintes palavras-chave têm significados especiais para onde carregar o URL: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

Nota:
  * Definir KTargetBlank em elementos <a> fornece implicitamente o mesmo comportamento rel
    que definir rel="noopener" que não define window.opener. Consulte a compatibilidade do
    navegador para obter o status do suporte.

func (*TagForm) Title 

func (e *TagForm) Title(title string) (ref *TagForm)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagForm) Translate 

func (e *TagForm) Translate(translate Translate) (ref *TagForm)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagImage 

type TagImage struct {
	// contains filtered or unexported fields
}

func (*TagImage) AccessKey 

func (e *TagImage) AccessKey(key string) (ref *TagImage)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagImage) Alt 

func (e *TagImage) Alt(alt string) (ref *TagImage)

Alt

English: 

The alt attribute provides alternative text for the image, displaying the value of the attribute
if the image src is missing or otherwise fails to load.

Português: 

O atributo alt fornece texto alternativo para a imagem, exibindo o valor do atributo se o src da
imagem estiver ausente ou falhar ao carregar.

func (*TagImage) Append 

func (e *TagImage) Append(append interface{}) (ref *TagImage)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagImage) AppendById 

func (e *TagImage) AppendById(appendId string) (ref *TagImage)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagImage) Autofocus 

func (e *TagImage) Autofocus(autofocus bool) (ref *TagImage)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagImage) Class 

func (e *TagImage) Class(class ...string) (ref *TagImage)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagImage) ContentEditable 

func (e *TagImage) ContentEditable(editable bool) (ref *TagImage)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagImage) CreateElement 

func (e *TagImage) CreateElement(tag Tag, src string, width, height int, waitLoad bool) (ref *TagImage)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagImage) CrossOrigin 

func (e *TagImage) CrossOrigin(cross CrossOrigin) (ref *TagImage)

CrossOrigin

English: 

Indicates if the fetching of the image must be done using a CORS request.

Image data from a CORS-enabled image returned from a CORS request can be reused in the <canvas> element without being marked "tainted".

If the crossorigin attribute is not specified, then a non-CORS request is sent (without the Origin request header), and the browser marks the image as tainted and restricts access to its image data, preventing its usage in <canvas> elements.

If the crossorigin attribute is specified, then a CORS request is sent (with the Origin request header); but if the server does not opt into allowing cross-origin access to the image data by the origin site (by not sending any Access-Control-Allow-Origin response header, or by not including the site's origin in any Access-Control-Allow-Origin response header it does send), then the browser blocks the image from loading, and logs a CORS error to the devtools console.

Português: 

Indica se a busca da imagem deve ser feita por meio de uma solicitação CORS.

Os dados de imagem de uma imagem habilitada para CORS retornados de uma solicitação CORS podem ser reutilizados no elemento <canvas> sem serem marcados como "contaminados".

Se o atributo crossorigin não for especificado, uma solicitação não CORS é enviada (sem o cabeçalho da solicitação Origin) e o navegador marca a imagem como contaminada e restringe o acesso aos dados da imagem, impedindo seu uso em elementos <canvas>.

Se o atributo crossorigin for especificado, uma solicitação CORS será enviada (com o cabeçalho da solicitação Origem); mas se o servidor não permitir o acesso de origem cruzada aos dados da imagem pelo site de origem (não enviando nenhum cabeçalho de resposta Access-Control-Allow-Origin ou não incluindo a origem do site em qualquer Access-Control-Allow -Origin response header que ele envia), o navegador bloqueia o carregamento da imagem e registra um erro CORS no console devtools.

func (*TagImage) Data 

func (e *TagImage) Data(data map[string]string) (ref *TagImage)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagImage) Decoding 

func (e *TagImage) Decoding(decoding Decoding) (ref *TagImage)

Decoding

English: 

Provides an image decoding hint to the browser.

Português: 

Fornece uma dica de decodificação de imagem para o navegador.

func (*TagImage) Dir 

func (e *TagImage) Dir(dir Dir) (ref *TagImage)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagImage) Draggable 

func (e *TagImage) Draggable(draggable Draggable) (ref *TagImage)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagImage) EnterKeyHint 

func (e *TagImage) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagImage)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagImage) FetchPriority 

func (e *TagImage) FetchPriority(priority FetchPriority) (ref *TagImage)

FetchPriority

English: 

Provides a hint of the relative priority to use when fetching the image.

Português: 

Fornece uma dica da prioridade relativa a ser usada ao buscar a imagem.

func (TagImage) GetJs 

func (e TagImage) GetJs() (element js.Value)

func (*TagImage) GetX 

func (e *TagImage) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagImage) GetXY 

func (e *TagImage) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagImage) GetY 

func (e *TagImage) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagImage) Hidden 

func (e *TagImage) Hidden() (ref *TagImage)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagImage) Id 

func (e *TagImage) Id(id string) (ref *TagImage)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagImage) InputMode 

func (e *TagImage) InputMode(inputMode InputMode) (ref *TagImage)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagImage) Is 

func (e *TagImage) Is(is string) (ref *TagImage)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagImage) IsMap 

func (e *TagImage) IsMap(isMap bool) (ref *TagImage)

IsMap

English: 

This Boolean attribute indicates that the image is part of a server-side map. If so, the
coordinates where the user clicked on the image are sent to the server.

 Note:
   * This attribute is allowed only if the <img> element is a descendant of an <a> element with a
     valid href attribute. This gives users without pointing devices a fallback destination.

Português: 

Este atributo booleano indica que a imagem faz parte de um mapa do lado do servidor.
Se sim, as coordenadas onde o usuário clicou na imagem são enviadas para o servidor.

 Nota:
   * Este atributo é permitido somente se o elemento <img> for descendente de um elemento <a> com
     um atributo href válido. Isso oferece aos usuários sem dispositivos apontadores um destino
     de fallback.

func (*TagImage) ItemDrop 

func (e *TagImage) ItemDrop(itemprop string) (ref *TagImage)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagImage) ItemId 

func (e *TagImage) ItemId(id string) (ref *TagImage)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagImage) ItemRef 

func (e *TagImage) ItemRef(itemref string) (ref *TagImage)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagImage) ItemType 

func (e *TagImage) ItemType(itemType string) (ref *TagImage)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagImage) Lang 

func (e *TagImage) Lang(language Language) (ref *TagImage)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagImage) Nonce 

func (e *TagImage) Nonce(part ...string) (ref *TagImage)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagImage) ReferrerPolicy 

func (e *TagImage) ReferrerPolicy(referrerPolicy ReferrerPolicy) (ref *TagImage)

ReferrerPolicy

English: 

How much of the referrer to send when following the link.

 KRefPolicyNoReferrer: The Referer header will not be sent.
 KRefPolicyNoReferrerWhenDowngrade: The Referer header will not be sent to origins without TLS
   (HTTPS).
 KRefPolicyOrigin: The sent referrer will be limited to the origin of the referring page: its
   scheme, host, and port.
 KRefPolicyOriginWhenCrossOrigin: The referrer sent to other origins will be limited to the
   scheme, the host, and the port. Navigations on the same origin will still include the path.
 KRefPolicySameOrigin: A referrer will be sent for same origin, but cross-origin requests will
   contain no referrer information.
 KRefPolicyStrictOrigin: Only send the origin of the document as the referrer when the protocol
   security level stays the same (HTTPS→HTTPS), but don't send it to a less secure destination
   (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (default): Send a full URL when performing a same-origin
   request, only send the origin when the protocol security level stays the same (HTTPS→HTTPS),
   and send no header to a less secure destination (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: The referrer will include the origin and the path (but not the fragment,
   password, or username). This value is unsafe, because it leaks origins and paths from
   TLS-protected resources to insecure origins.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

Português: 

Quanto do referenciador enviar ao seguir o link.

 KRefPolicyNoReferrer: O cabeçalho Referer não será enviado.
 KRefPolicyNoReferrerWhenDowngrade: O cabeçalho Referer não será enviado para origens sem TLS
   (HTTPS).
 KRefPolicyOrigin: O referenciador enviado será limitado à origem da página de referência: seu
   esquema, host e porta.
 KRefPolicyOriginWhenCrossOrigin: O referenciador enviado para outras origens será limitado ao
   esquema, ao host e à porta. As navegações na mesma origem ainda incluirão o caminho.
 KRefPolicySameOrigin: Um referenciador será enviado para a mesma origem, mas as solicitações de
   origem cruzada não conterão informações de referenciador.
 KRefPolicyStrictOrigin: Só envie a origem do documento como referenciador quando o nível de
   segurança do protocolo permanecer o mesmo (HTTPS→HTTPS), mas não envie para um destino menos
   seguro (HTTPS→HTTP).
 KRefPolicyStrictOriginWhenCrossOrigin (padrão): Envie uma URL completa ao realizar uma
   solicitação de mesma origem, envie a origem apenas quando o nível de segurança do protocolo
   permanecer o mesmo (HTTPS→HTTPS) e não envie nenhum cabeçalho para um destino menos seguro
   (HTTPS→HTTP).
 KRefPolicyUnsafeUrl: O referenciador incluirá a origem e o caminho (mas não o fragmento, a senha
   ou o nome de usuário). Esse valor não é seguro porque vaza origens e caminhos de recursos
   protegidos por TLS para origens inseguras.

 Note:
   * Experimental. Expect behavior to change in the future. (04/2022)

func (*TagImage) SetX 

func (e *TagImage) SetX(x int) (ref *TagImage)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagImage) SetXY 

func (e *TagImage) SetXY(x, y int) (ref *TagImage)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagImage) SetY 

func (e *TagImage) SetY(y int) (ref *TagImage)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagImage) Sizes 

func (e *TagImage) Sizes(sizes string) (ref *TagImage)

Sizes

English: 

One or more strings separated by commas, indicating a set of source sizes. Each source size
consists of:
  1 A media condition. This must be omitted for the last item in the list.
  2 A source size value.

Media Conditions describe properties of the viewport, not of the image. For example, (max-height: 500px) 1000px proposes to use a source of 1000px width, if the viewport is not higher than 500px.

Source size values specify the intended display size of the image. User agents use the current source size to select one of the sources supplied by the srcset attribute, when those sources are described using width (w) descriptors. The selected source size affects the intrinsic size of the image (the image's display size if no CSS styling is applied). If the srcset attribute is absent, or contains no values with a width descriptor, then the sizes attribute has no effect.

Português: 

Uma ou mais strings separadas por vírgulas, indicando um conjunto de tamanhos de origem. Cada
tamanho de origem consiste em:
  1 Uma condição de mídia. Isso deve ser omitido para o último item da lista.
  2 Um valor de tamanho de origem.

As condições de mídia descrevem as propriedades da janela de visualização, não da imagem. Por exemplo, (max-height: 500px) 1000px propõe usar uma fonte de 1000px de largura, se a janela de visualização não for maior que 500px.

Os valores de tamanho de origem especificam o tamanho de exibição pretendido da imagem. Os agentes do usuário usam o tamanho da fonte atual para selecionar uma das fontes fornecidas pelo atributo srcset, quando essas fontes são descritas usando descritores de largura (w). O tamanho de origem selecionado afeta o tamanho intrínseco da imagem (o tamanho de exibição da imagem se nenhum estilo CSS for aplicado). Se o atributo srcset estiver ausente ou não contiver valores com um descritor de largura, o atributo tamanhos não terá efeito.

func (*TagImage) Slot 

func (e *TagImage) Slot(slot string) (ref *TagImage)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagImage) Spellcheck 

func (e *TagImage) Spellcheck(spell bool) (ref *TagImage)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagImage) Src 

func (e *TagImage) Src(src string) (ref *TagImage)

Src

English: 

The image URL. Mandatory for the <img> element. On browsers supporting srcset, src is treated
like a candidate image with a pixel density descriptor 1x, unless an image with this pixel
density descriptor is already defined in srcset, or unless srcset contains w descriptors.

Português: 

O URL da imagem. Obrigatório para o elemento <img>. Em navegadores que suportam srcset, src é
tratado como uma imagem candidata com um descritor de densidade de pixels 1x, a menos que uma
imagem com esse descritor de densidade de pixels já esteja definida em srcset, ou a menos que
srcset contenha descritores w.

func (*TagImage) SrcSet 

func (e *TagImage) SrcSet(srcSet string) (ref *TagImage)

SrcSet

English: 

One or more strings separated by commas, indicating possible image sources for the user agent to
use. Each string is composed of:
  1 A URL to an image
  2 Optionally, whitespace followed by one of:
    * A width descriptor (a positive integer directly followed by w). The width descriptor is
      divided by the source size given in the sizes attribute to calculate the effective pixel
      density.
    * A pixel density descriptor (a positive floating point number directly followed by x).

If no descriptor is specified, the source is assigned the default descriptor of 1x.

It is incorrect to mix width descriptors and pixel density descriptors in the same srcset attribute. Duplicate descriptors (for instance, two sources in the same srcset which are both described with 2x) are also invalid.

The user agent selects any of the available sources at its discretion. This provides them with significant leeway to tailor their selection based on things like user preferences or bandwidth conditions. See our Responsive images tutorial for an example.

Português: 

Uma ou mais strings separadas por vírgulas, indicando possíveis fontes de imagem para o agente do
usuário usar. Cada corda é composta por:
  1 Um URL para uma imagem
  2 Opcionalmente, espaço em branco seguido por um dos seguintes:
    * Um descritor de largura (um inteiro positivo seguido diretamente por w). O descritor de
      largura é dividido pelo tamanho da fonte fornecido no atributo de tamanhos para calcular a
      densidade de pixels efetiva.
    * Um descritor de densidade de pixels (um número de ponto flutuante positivo seguido
      diretamente por x).

Se nenhum descritor for especificado, a origem receberá o descritor padrão de 1x.

É incorreto misturar descritores de largura e descritores de densidade de pixels no mesmo atributo srcset. Descritores duplicados (por exemplo, duas fontes no mesmo srcset que são ambas descritas com 2x) também são inválidas.

O agente do usuário seleciona qualquer uma das fontes disponíveis a seu critério. Isso fornece a eles uma margem de manobra significativa para personalizar sua seleção com base em coisas como preferências do usuário ou condições de largura de banda. Veja nosso tutorial de imagens responsivas para obter um exemplo.

func (*TagImage) Style 

func (e *TagImage) Style(style string) (ref *TagImage)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagImage) TabIndex 

func (e *TagImage) TabIndex(index int) (ref *TagImage)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagImage) Title 

func (e *TagImage) Title(title string) (ref *TagImage)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagImage) Translate 

func (e *TagImage) Translate(translate Translate) (ref *TagImage)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagImage) UseMap 

func (e *TagImage) UseMap(useMap bool) (ref *TagImage)

UseMap

English: 

The partial URL (starting with #) of an image map associated with the element.

 Note:
   * You cannot use this attribute if the <img> element is inside an <a> or <button> element.

Português: 

The partial URL (starting with #) of an image map associated with the element.

 Note:
   * You cannot use this attribute if the <img> element is inside an <a> or <button> element.

func (*TagImage) Width 

func (e *TagImage) Width(width int) (ref *TagImage)

Width

English: 

The intrinsic width of the image in pixels. Must be an integer without a unit.

Português: 

A largura intrínseca da imagem em pixels. Deve ser um número inteiro sem uma unidade.

type TagInputButton 

type TagInputButton struct {
	// contains filtered or unexported fields
}

func (*TagInputButton) AccessKey 

func (e *TagInputButton) AccessKey(key string) (ref *TagInputButton)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputButton) Append 

func (e *TagInputButton) Append(append interface{}) (ref *TagInputButton)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputButton) AppendById 

func (e *TagInputButton) AppendById(appendId string) (ref *TagInputButton)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputButton) Autocomplete 

func (e *TagInputButton) Autocomplete(autocomplete Autocomplete) (ref *TagInputButton)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputButton) Autofocus 

func (e *TagInputButton) Autofocus(autofocus bool) (ref *TagInputButton)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputButton) Class 

func (e *TagInputButton) Class(class ...string) (ref *TagInputButton)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputButton) ContentEditable 

func (e *TagInputButton) ContentEditable(editable bool) (ref *TagInputButton)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputButton) CreateElement 

func (e *TagInputButton) CreateElement(tag Tag) (ref *TagInputButton)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputButton) Data 

func (e *TagInputButton) Data(data map[string]string) (ref *TagInputButton)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputButton) Dir 

func (e *TagInputButton) Dir(dir Dir) (ref *TagInputButton)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputButton) Disabled 

func (e *TagInputButton) Disabled(disabled bool) (ref *TagInputButton)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputButton) Draggable 

func (e *TagInputButton) Draggable(draggable Draggable) (ref *TagInputButton)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputButton) EnterKeyHint 

func (e *TagInputButton) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputButton)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputButton) Form 

func (e *TagInputButton) Form(form string) (ref *TagInputButton)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputButton) GetX 

func (e *TagInputButton) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputButton) GetXY 

func (e *TagInputButton) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputButton) GetY 

func (e *TagInputButton) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputButton) Hidden 

func (e *TagInputButton) Hidden() (ref *TagInputButton)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputButton) Id 

func (e *TagInputButton) Id(id string) (ref *TagInputButton)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputButton) InputMode 

func (e *TagInputButton) InputMode(inputMode InputMode) (ref *TagInputButton)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputButton) Is 

func (e *TagInputButton) Is(is string) (ref *TagInputButton)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputButton) ItemDrop 

func (e *TagInputButton) ItemDrop(itemprop string) (ref *TagInputButton)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputButton) ItemId 

func (e *TagInputButton) ItemId(id string) (ref *TagInputButton)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputButton) ItemRef 

func (e *TagInputButton) ItemRef(itemref string) (ref *TagInputButton)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputButton) ItemType 

func (e *TagInputButton) ItemType(itemType string) (ref *TagInputButton)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputButton) Lang 

func (e *TagInputButton) Lang(language Language) (ref *TagInputButton)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputButton) List 

func (e *TagInputButton) List(list string) (ref *TagInputButton)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputButton) Name 

func (e *TagInputButton) Name(name string) (ref *TagInputButton)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputButton) Nonce 

func (e *TagInputButton) Nonce(part ...string) (ref *TagInputButton)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputButton) ReadOnly 

func (e *TagInputButton) ReadOnly(readonly bool) (ref *TagInputButton)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputButton) Required 

func (e *TagInputButton) Required(required bool) (ref *TagInputButton)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputButton) SetX 

func (e *TagInputButton) SetX(x int) (ref *TagInputButton)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputButton) SetXY 

func (e *TagInputButton) SetXY(x, y int) (ref *TagInputButton)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputButton) SetY 

func (e *TagInputButton) SetY(y int) (ref *TagInputButton)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputButton) Slot 

func (e *TagInputButton) Slot(slot string) (ref *TagInputButton)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputButton) Spellcheck 

func (e *TagInputButton) Spellcheck(spell bool) (ref *TagInputButton)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputButton) Style 

func (e *TagInputButton) Style(style string) (ref *TagInputButton)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputButton) TabIndex 

func (e *TagInputButton) TabIndex(index int) (ref *TagInputButton)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputButton) Title 

func (e *TagInputButton) Title(title string) (ref *TagInputButton)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputButton) Translate 

func (e *TagInputButton) Translate(translate Translate) (ref *TagInputButton)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputButton) Type 

func (e *TagInputButton) Type(inputType InputType) (ref *TagInputButton)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputButton) Value 

func (e *TagInputButton) Value(value string) (ref *TagInputButton)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputCheckBox 

type TagInputCheckBox struct {
	// contains filtered or unexported fields
}

func (*TagInputCheckBox) AccessKey 

func (e *TagInputCheckBox) AccessKey(key string) (ref *TagInputCheckBox)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputCheckBox) Append 

func (e *TagInputCheckBox) Append(append interface{}) (ref *TagInputCheckBox)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputCheckBox) AppendById 

func (e *TagInputCheckBox) AppendById(appendId string) (ref *TagInputCheckBox)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputCheckBox) Autocomplete 

func (e *TagInputCheckBox) Autocomplete(autocomplete Autocomplete) (ref *TagInputCheckBox)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputCheckBox) Autofocus 

func (e *TagInputCheckBox) Autofocus(autofocus bool) (ref *TagInputCheckBox)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputCheckBox) Checked 

func (e *TagInputCheckBox) Checked(checked bool) (ref *TagInputCheckBox)

Checked

English: 

Valid for both radio and checkbox types, checked is a Boolean attribute. If present on a radio
type, it indicates that the radio button is the currently selected one in the group of same-named
radio buttons. If present on a checkbox type, it indicates that the checkbox is checked by default
(when the page loads).
It does not indicate whether this checkbox is currently checked: if the checkbox's state is
changed, this content attribute does not reflect the change.
(Only the HTMLInputElement's checked IDL attribute is updated.)

 Note:
   * Unlike other input controls, a checkboxes and radio buttons value are only included in the
     submitted data if they are currently checked. If they are, the name and the value(s) of the
     checked controls are submitted.
     For example, if a checkbox whose name is fruit has a value of cherry, and the checkbox is
     checked, the form data submitted will include fruit=cherry. If the checkbox isn't active,
     it isn't listed in the form data at all. The default value for checkboxes and radio buttons
     is on.

Português: 

Válido para os tipos de rádio e caixa de seleção, marcado é um atributo booleano. Se estiver
presente em um tipo de rádio, indica que o botão de opção é o selecionado atualmente no grupo de
botões de opção com o mesmo nome. Se estiver presente em um tipo de caixa de seleção, indica que
a caixa de seleção está marcada por padrão (quando a página é carregada). Não indica se esta caixa
de seleção está marcada no momento: se o estado da caixa de seleção for alterado, esse atributo
de conteúdo não reflete a alteração.
(Apenas o atributo IDL verificado do HTMLInputElement é atualizado.)

 Nota:
   * Ao contrário de outros controles de entrada, um valor de caixas de seleção e botões de opção
     só são incluídos nos dados enviados se estiverem marcados no momento. Se estiverem, o nome e
     o(s) valor(es) dos controles verificados são enviados.
     Por exemplo, se uma caixa de seleção cujo nome é fruta tiver o valor cereja e a caixa de
     seleção estiver marcada, os dados do formulário enviados incluirão fruta=cereja.
     Se a caixa de seleção não estiver ativa, ela não está listada nos dados do formulário.
     O valor padrão para caixas de seleção e botões de opção é ativado.

func (*TagInputCheckBox) Class 

func (e *TagInputCheckBox) Class(class ...string) (ref *TagInputCheckBox)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputCheckBox) ContentEditable 

func (e *TagInputCheckBox) ContentEditable(editable bool) (ref *TagInputCheckBox)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputCheckBox) CreateElement 

func (e *TagInputCheckBox) CreateElement(tag Tag) (ref *TagInputCheckBox)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputCheckBox) Data 

func (e *TagInputCheckBox) Data(data map[string]string) (ref *TagInputCheckBox)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputCheckBox) Dir 

func (e *TagInputCheckBox) Dir(dir Dir) (ref *TagInputCheckBox)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputCheckBox) Disabled 

func (e *TagInputCheckBox) Disabled(disabled bool) (ref *TagInputCheckBox)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputCheckBox) Draggable 

func (e *TagInputCheckBox) Draggable(draggable Draggable) (ref *TagInputCheckBox)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputCheckBox) EnterKeyHint 

func (e *TagInputCheckBox) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputCheckBox)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputCheckBox) Form 

func (e *TagInputCheckBox) Form(form string) (ref *TagInputCheckBox)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputCheckBox) GetX 

func (e *TagInputCheckBox) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputCheckBox) GetXY 

func (e *TagInputCheckBox) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputCheckBox) GetY 

func (e *TagInputCheckBox) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputCheckBox) Hidden 

func (e *TagInputCheckBox) Hidden() (ref *TagInputCheckBox)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputCheckBox) Id 

func (e *TagInputCheckBox) Id(id string) (ref *TagInputCheckBox)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputCheckBox) InputMode 

func (e *TagInputCheckBox) InputMode(inputMode InputMode) (ref *TagInputCheckBox)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputCheckBox) Is 

func (e *TagInputCheckBox) Is(is string) (ref *TagInputCheckBox)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputCheckBox) ItemDrop 

func (e *TagInputCheckBox) ItemDrop(itemprop string) (ref *TagInputCheckBox)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputCheckBox) ItemId 

func (e *TagInputCheckBox) ItemId(id string) (ref *TagInputCheckBox)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputCheckBox) ItemRef 

func (e *TagInputCheckBox) ItemRef(itemref string) (ref *TagInputCheckBox)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputCheckBox) ItemType 

func (e *TagInputCheckBox) ItemType(itemType string) (ref *TagInputCheckBox)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputCheckBox) Lang 

func (e *TagInputCheckBox) Lang(language Language) (ref *TagInputCheckBox)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputCheckBox) List 

func (e *TagInputCheckBox) List(list string) (ref *TagInputCheckBox)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputCheckBox) Name 

func (e *TagInputCheckBox) Name(name string) (ref *TagInputCheckBox)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputCheckBox) Nonce 

func (e *TagInputCheckBox) Nonce(part ...string) (ref *TagInputCheckBox)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputCheckBox) ReadOnly 

func (e *TagInputCheckBox) ReadOnly(readonly bool) (ref *TagInputCheckBox)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputCheckBox) Required 

func (e *TagInputCheckBox) Required(required bool) (ref *TagInputCheckBox)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputCheckBox) SetX 

func (e *TagInputCheckBox) SetX(x int) (ref *TagInputCheckBox)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputCheckBox) SetXY 

func (e *TagInputCheckBox) SetXY(x, y int) (ref *TagInputCheckBox)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputCheckBox) SetY 

func (e *TagInputCheckBox) SetY(y int) (ref *TagInputCheckBox)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputCheckBox) Slot 

func (e *TagInputCheckBox) Slot(slot string) (ref *TagInputCheckBox)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputCheckBox) Spellcheck 

func (e *TagInputCheckBox) Spellcheck(spell bool) (ref *TagInputCheckBox)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputCheckBox) Style 

func (e *TagInputCheckBox) Style(style string) (ref *TagInputCheckBox)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputCheckBox) TabIndex 

func (e *TagInputCheckBox) TabIndex(index int) (ref *TagInputCheckBox)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputCheckBox) Title 

func (e *TagInputCheckBox) Title(title string) (ref *TagInputCheckBox)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputCheckBox) Translate 

func (e *TagInputCheckBox) Translate(translate Translate) (ref *TagInputCheckBox)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputCheckBox) Type 

func (e *TagInputCheckBox) Type(inputType InputType) (ref *TagInputCheckBox)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputCheckBox) Value 

func (e *TagInputCheckBox) Value(value string) (ref *TagInputCheckBox)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputColor 

type TagInputColor struct {
	// contains filtered or unexported fields
}

func (*TagInputColor) AccessKey 

func (e *TagInputColor) AccessKey(key string) (ref *TagInputColor)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputColor) Append 

func (e *TagInputColor) Append(append interface{}) (ref *TagInputColor)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputColor) AppendById 

func (e *TagInputColor) AppendById(appendId string) (ref *TagInputColor)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputColor) Autocomplete 

func (e *TagInputColor) Autocomplete(autocomplete Autocomplete) (ref *TagInputColor)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputColor) Autofocus 

func (e *TagInputColor) Autofocus(autofocus bool) (ref *TagInputColor)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputColor) Class 

func (e *TagInputColor) Class(class ...string) (ref *TagInputColor)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputColor) ContentEditable 

func (e *TagInputColor) ContentEditable(editable bool) (ref *TagInputColor)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputColor) CreateElement 

func (e *TagInputColor) CreateElement(tag Tag) (ref *TagInputColor)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputColor) Data 

func (e *TagInputColor) Data(data map[string]string) (ref *TagInputColor)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputColor) Dir 

func (e *TagInputColor) Dir(dir Dir) (ref *TagInputColor)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputColor) Disabled 

func (e *TagInputColor) Disabled(disabled bool) (ref *TagInputColor)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputColor) Draggable 

func (e *TagInputColor) Draggable(draggable Draggable) (ref *TagInputColor)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputColor) EnterKeyHint 

func (e *TagInputColor) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputColor)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputColor) Form 

func (e *TagInputColor) Form(form string) (ref *TagInputColor)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputColor) GetX 

func (e *TagInputColor) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputColor) GetXY 

func (e *TagInputColor) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputColor) GetY 

func (e *TagInputColor) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputColor) Hidden 

func (e *TagInputColor) Hidden() (ref *TagInputColor)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputColor) Id 

func (e *TagInputColor) Id(id string) (ref *TagInputColor)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputColor) InputMode 

func (e *TagInputColor) InputMode(inputMode InputMode) (ref *TagInputColor)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputColor) Is 

func (e *TagInputColor) Is(is string) (ref *TagInputColor)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputColor) ItemDrop 

func (e *TagInputColor) ItemDrop(itemprop string) (ref *TagInputColor)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputColor) ItemId 

func (e *TagInputColor) ItemId(id string) (ref *TagInputColor)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputColor) ItemRef 

func (e *TagInputColor) ItemRef(itemref string) (ref *TagInputColor)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputColor) ItemType 

func (e *TagInputColor) ItemType(itemType string) (ref *TagInputColor)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputColor) Lang 

func (e *TagInputColor) Lang(language Language) (ref *TagInputColor)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputColor) List 

func (e *TagInputColor) List(list string) (ref *TagInputColor)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputColor) Max 

func (e *TagInputColor) Max(max int) (ref *TagInputColor)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputColor) Min 

func (e *TagInputColor) Min(min int) (ref *TagInputColor)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputColor) MinLength 

func (e *TagInputColor) MinLength(minlength int) (ref *TagInputColor)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputColor) Name 

func (e *TagInputColor) Name(name string) (ref *TagInputColor)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputColor) Nonce 

func (e *TagInputColor) Nonce(part ...string) (ref *TagInputColor)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputColor) ReadOnly 

func (e *TagInputColor) ReadOnly(readonly bool) (ref *TagInputColor)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputColor) Required 

func (e *TagInputColor) Required(required bool) (ref *TagInputColor)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputColor) SetX 

func (e *TagInputColor) SetX(x int) (ref *TagInputColor)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputColor) SetXY 

func (e *TagInputColor) SetXY(x, y int) (ref *TagInputColor)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputColor) SetY 

func (e *TagInputColor) SetY(y int) (ref *TagInputColor)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputColor) Slot 

func (e *TagInputColor) Slot(slot string) (ref *TagInputColor)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputColor) Spellcheck 

func (e *TagInputColor) Spellcheck(spell bool) (ref *TagInputColor)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputColor) Step 

func (e *TagInputColor) Step(step int) (ref *TagInputColor)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputColor) Style 

func (e *TagInputColor) Style(style string) (ref *TagInputColor)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputColor) TabIndex 

func (e *TagInputColor) TabIndex(index int) (ref *TagInputColor)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputColor) Title 

func (e *TagInputColor) Title(title string) (ref *TagInputColor)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputColor) Translate 

func (e *TagInputColor) Translate(translate Translate) (ref *TagInputColor)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputColor) Type 

func (e *TagInputColor) Type(inputType InputType) (ref *TagInputColor)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputColor) Value 

func (e *TagInputColor) Value(value string) (ref *TagInputColor)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputDate 

type TagInputDate struct {
	// contains filtered or unexported fields
}

func (*TagInputDate) AccessKey 

func (e *TagInputDate) AccessKey(key string) (ref *TagInputDate)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputDate) Append 

func (e *TagInputDate) Append(append interface{}) (ref *TagInputDate)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDate) AppendById 

func (e *TagInputDate) AppendById(appendId string) (ref *TagInputDate)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDate) Autocomplete 

func (e *TagInputDate) Autocomplete(autocomplete Autocomplete) (ref *TagInputDate)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputDate) Autofocus 

func (e *TagInputDate) Autofocus(autofocus bool) (ref *TagInputDate)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputDate) Class 

func (e *TagInputDate) Class(class ...string) (ref *TagInputDate)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputDate) ContentEditable 

func (e *TagInputDate) ContentEditable(editable bool) (ref *TagInputDate)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputDate) CreateElement 

func (e *TagInputDate) CreateElement(tag Tag) (ref *TagInputDate)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputDate) Data 

func (e *TagInputDate) Data(data map[string]string) (ref *TagInputDate)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputDate) Dir 

func (e *TagInputDate) Dir(dir Dir) (ref *TagInputDate)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputDate) Disabled 

func (e *TagInputDate) Disabled(disabled bool) (ref *TagInputDate)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputDate) Draggable 

func (e *TagInputDate) Draggable(draggable Draggable) (ref *TagInputDate)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputDate) EnterKeyHint 

func (e *TagInputDate) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputDate)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputDate) Form 

func (e *TagInputDate) Form(form string) (ref *TagInputDate)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputDate) GetX 

func (e *TagInputDate) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputDate) GetXY 

func (e *TagInputDate) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputDate) GetY 

func (e *TagInputDate) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputDate) Hidden 

func (e *TagInputDate) Hidden() (ref *TagInputDate)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputDate) Id 

func (e *TagInputDate) Id(id string) (ref *TagInputDate)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputDate) InputMode 

func (e *TagInputDate) InputMode(inputMode InputMode) (ref *TagInputDate)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputDate) Is 

func (e *TagInputDate) Is(is string) (ref *TagInputDate)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputDate) ItemDrop 

func (e *TagInputDate) ItemDrop(itemprop string) (ref *TagInputDate)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputDate) ItemId 

func (e *TagInputDate) ItemId(id string) (ref *TagInputDate)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputDate) ItemRef 

func (e *TagInputDate) ItemRef(itemref string) (ref *TagInputDate)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputDate) ItemType 

func (e *TagInputDate) ItemType(itemType string) (ref *TagInputDate)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputDate) Lang 

func (e *TagInputDate) Lang(language Language) (ref *TagInputDate)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputDate) List 

func (e *TagInputDate) List(list string) (ref *TagInputDate)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputDate) Max 

func (e *TagInputDate) Max(max int) (ref *TagInputDate)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDate) Min 

func (e *TagInputDate) Min(min int) (ref *TagInputDate)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDate) Name 

func (e *TagInputDate) Name(name string) (ref *TagInputDate)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputDate) Nonce 

func (e *TagInputDate) Nonce(part ...string) (ref *TagInputDate)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputDate) ReadOnly 

func (e *TagInputDate) ReadOnly(readonly bool) (ref *TagInputDate)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputDate) Required 

func (e *TagInputDate) Required(required bool) (ref *TagInputDate)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputDate) SetX 

func (e *TagInputDate) SetX(x int) (ref *TagInputDate)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputDate) SetXY 

func (e *TagInputDate) SetXY(x, y int) (ref *TagInputDate)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputDate) SetY 

func (e *TagInputDate) SetY(y int) (ref *TagInputDate)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputDate) Slot 

func (e *TagInputDate) Slot(slot string) (ref *TagInputDate)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputDate) Spellcheck 

func (e *TagInputDate) Spellcheck(spell bool) (ref *TagInputDate)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputDate) Step 

func (e *TagInputDate) Step(step int) (ref *TagInputDate)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputDate) Style 

func (e *TagInputDate) Style(style string) (ref *TagInputDate)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDate) TabIndex 

func (e *TagInputDate) TabIndex(index int) (ref *TagInputDate)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDate) Title 

func (e *TagInputDate) Title(title string) (ref *TagInputDate)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDate) Translate 

func (e *TagInputDate) Translate(translate Translate) (ref *TagInputDate)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputDate) Type 

func (e *TagInputDate) Type(inputType InputType) (ref *TagInputDate)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputDate) Value 

func (e *TagInputDate) Value(value string) (ref *TagInputDate)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputDateTimeLocal 

type TagInputDateTimeLocal struct {
	// contains filtered or unexported fields
}

func (*TagInputDateTimeLocal) AccessKey 

func (e *TagInputDateTimeLocal) AccessKey(key string) (ref *TagInputDateTimeLocal)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputDateTimeLocal) Append 

func (e *TagInputDateTimeLocal) Append(append interface{}) (ref *TagInputDateTimeLocal)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDateTimeLocal) AppendById 

func (e *TagInputDateTimeLocal) AppendById(appendId string) (ref *TagInputDateTimeLocal)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputDateTimeLocal) Autocomplete 

func (e *TagInputDateTimeLocal) Autocomplete(autocomplete Autocomplete) (ref *TagInputDateTimeLocal)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputDateTimeLocal) Autofocus 

func (e *TagInputDateTimeLocal) Autofocus(autofocus bool) (ref *TagInputDateTimeLocal)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputDateTimeLocal) Class 

func (e *TagInputDateTimeLocal) Class(class ...string) (ref *TagInputDateTimeLocal)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputDateTimeLocal) ContentEditable 

func (e *TagInputDateTimeLocal) ContentEditable(editable bool) (ref *TagInputDateTimeLocal)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputDateTimeLocal) CreateElement 

func (e *TagInputDateTimeLocal) CreateElement(tag Tag) (ref *TagInputDateTimeLocal)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputDateTimeLocal) Data 

func (e *TagInputDateTimeLocal) Data(data map[string]string) (ref *TagInputDateTimeLocal)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputDateTimeLocal) Dir 

func (e *TagInputDateTimeLocal) Dir(dir Dir) (ref *TagInputDateTimeLocal)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputDateTimeLocal) Disabled 

func (e *TagInputDateTimeLocal) Disabled(disabled bool) (ref *TagInputDateTimeLocal)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputDateTimeLocal) Draggable 

func (e *TagInputDateTimeLocal) Draggable(draggable Draggable) (ref *TagInputDateTimeLocal)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputDateTimeLocal) EnterKeyHint 

func (e *TagInputDateTimeLocal) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputDateTimeLocal)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputDateTimeLocal) Form 

func (e *TagInputDateTimeLocal) Form(form string) (ref *TagInputDateTimeLocal)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputDateTimeLocal) GetX 

func (e *TagInputDateTimeLocal) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputDateTimeLocal) GetXY 

func (e *TagInputDateTimeLocal) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputDateTimeLocal) GetY 

func (e *TagInputDateTimeLocal) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputDateTimeLocal) Hidden 

func (e *TagInputDateTimeLocal) Hidden() (ref *TagInputDateTimeLocal)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputDateTimeLocal) Id 

func (e *TagInputDateTimeLocal) Id(id string) (ref *TagInputDateTimeLocal)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputDateTimeLocal) InputMode 

func (e *TagInputDateTimeLocal) InputMode(inputMode InputMode) (ref *TagInputDateTimeLocal)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputDateTimeLocal) Is 

func (e *TagInputDateTimeLocal) Is(is string) (ref *TagInputDateTimeLocal)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputDateTimeLocal) ItemDrop 

func (e *TagInputDateTimeLocal) ItemDrop(itemprop string) (ref *TagInputDateTimeLocal)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputDateTimeLocal) ItemId 

func (e *TagInputDateTimeLocal) ItemId(id string) (ref *TagInputDateTimeLocal)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputDateTimeLocal) ItemRef 

func (e *TagInputDateTimeLocal) ItemRef(itemref string) (ref *TagInputDateTimeLocal)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputDateTimeLocal) ItemType 

func (e *TagInputDateTimeLocal) ItemType(itemType string) (ref *TagInputDateTimeLocal)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputDateTimeLocal) Lang 

func (e *TagInputDateTimeLocal) Lang(language Language) (ref *TagInputDateTimeLocal)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputDateTimeLocal) List 

func (e *TagInputDateTimeLocal) List(list string) (ref *TagInputDateTimeLocal)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputDateTimeLocal) Max 

func (e *TagInputDateTimeLocal) Max(max int) (ref *TagInputDateTimeLocal)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDateTimeLocal) Min 

func (e *TagInputDateTimeLocal) Min(min int) (ref *TagInputDateTimeLocal)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputDateTimeLocal) Name 

func (e *TagInputDateTimeLocal) Name(name string) (ref *TagInputDateTimeLocal)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputDateTimeLocal) Nonce 

func (e *TagInputDateTimeLocal) Nonce(part ...string) (ref *TagInputDateTimeLocal)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputDateTimeLocal) ReadOnly 

func (e *TagInputDateTimeLocal) ReadOnly(readonly bool) (ref *TagInputDateTimeLocal)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputDateTimeLocal) Required 

func (e *TagInputDateTimeLocal) Required(required bool) (ref *TagInputDateTimeLocal)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputDateTimeLocal) SetX 

func (e *TagInputDateTimeLocal) SetX(x int) (ref *TagInputDateTimeLocal)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputDateTimeLocal) SetXY 

func (e *TagInputDateTimeLocal) SetXY(x, y int) (ref *TagInputDateTimeLocal)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputDateTimeLocal) SetY 

func (e *TagInputDateTimeLocal) SetY(y int) (ref *TagInputDateTimeLocal)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputDateTimeLocal) Slot 

func (e *TagInputDateTimeLocal) Slot(slot string) (ref *TagInputDateTimeLocal)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputDateTimeLocal) Spellcheck 

func (e *TagInputDateTimeLocal) Spellcheck(spell bool) (ref *TagInputDateTimeLocal)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputDateTimeLocal) Step 

func (e *TagInputDateTimeLocal) Step(step int) (ref *TagInputDateTimeLocal)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputDateTimeLocal) Style 

func (e *TagInputDateTimeLocal) Style(style string) (ref *TagInputDateTimeLocal)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDateTimeLocal) TabIndex 

func (e *TagInputDateTimeLocal) TabIndex(index int) (ref *TagInputDateTimeLocal)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDateTimeLocal) Title 

func (e *TagInputDateTimeLocal) Title(title string) (ref *TagInputDateTimeLocal)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputDateTimeLocal) Translate 

func (e *TagInputDateTimeLocal) Translate(translate Translate) (ref *TagInputDateTimeLocal)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputDateTimeLocal) Type 

func (e *TagInputDateTimeLocal) Type(inputType InputType) (ref *TagInputDateTimeLocal)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputDateTimeLocal) Value 

func (e *TagInputDateTimeLocal) Value(value string) (ref *TagInputDateTimeLocal)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputEMail 

type TagInputEMail struct {
	// contains filtered or unexported fields
}

func (*TagInputEMail) AccessKey 

func (e *TagInputEMail) AccessKey(key string) (ref *TagInputEMail)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputEMail) Append 

func (e *TagInputEMail) Append(append interface{}) (ref *TagInputEMail)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputEMail) AppendById 

func (e *TagInputEMail) AppendById(appendId string) (ref *TagInputEMail)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputEMail) Autocomplete 

func (e *TagInputEMail) Autocomplete(autocomplete Autocomplete) (ref *TagInputEMail)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputEMail) Autofocus 

func (e *TagInputEMail) Autofocus(autofocus bool) (ref *TagInputEMail)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputEMail) Class 

func (e *TagInputEMail) Class(class ...string) (ref *TagInputEMail)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputEMail) ContentEditable 

func (e *TagInputEMail) ContentEditable(editable bool) (ref *TagInputEMail)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputEMail) CreateElement 

func (e *TagInputEMail) CreateElement(tag Tag) (ref *TagInputEMail)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputEMail) Data 

func (e *TagInputEMail) Data(data map[string]string) (ref *TagInputEMail)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputEMail) Dir 

func (e *TagInputEMail) Dir(dir Dir) (ref *TagInputEMail)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputEMail) Disabled 

func (e *TagInputEMail) Disabled(disabled bool) (ref *TagInputEMail)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputEMail) Draggable 

func (e *TagInputEMail) Draggable(draggable Draggable) (ref *TagInputEMail)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputEMail) EnterKeyHint 

func (e *TagInputEMail) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputEMail)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputEMail) Form 

func (e *TagInputEMail) Form(form string) (ref *TagInputEMail)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputEMail) GetX 

func (e *TagInputEMail) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputEMail) GetXY 

func (e *TagInputEMail) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputEMail) GetY 

func (e *TagInputEMail) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputEMail) Hidden 

func (e *TagInputEMail) Hidden() (ref *TagInputEMail)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputEMail) Id 

func (e *TagInputEMail) Id(id string) (ref *TagInputEMail)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputEMail) InputMode 

func (e *TagInputEMail) InputMode(inputMode InputMode) (ref *TagInputEMail)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputEMail) Is 

func (e *TagInputEMail) Is(is string) (ref *TagInputEMail)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputEMail) ItemDrop 

func (e *TagInputEMail) ItemDrop(itemprop string) (ref *TagInputEMail)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputEMail) ItemId 

func (e *TagInputEMail) ItemId(id string) (ref *TagInputEMail)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputEMail) ItemRef 

func (e *TagInputEMail) ItemRef(itemref string) (ref *TagInputEMail)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputEMail) ItemType 

func (e *TagInputEMail) ItemType(itemType string) (ref *TagInputEMail)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputEMail) Lang 

func (e *TagInputEMail) Lang(language Language) (ref *TagInputEMail)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputEMail) List 

func (e *TagInputEMail) List(list string) (ref *TagInputEMail)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputEMail) Multiple 

func (e *TagInputEMail) Multiple(multiple bool) (ref *TagInputEMail)

Multiple

English: 

This Boolean attribute indicates that multiple options can be selected in the list. If it is not
specified, then only one option can be selected at a time. When multiple is specified, most
browsers will show a scrolling list box instead of a single line dropdown.

Português: 

Este atributo booleano indica que várias opções podem ser selecionadas na lista. Se não for
especificado, apenas uma opção pode ser selecionada por vez. Quando vários são especificados, a
maioria dos navegadores mostrará uma caixa de listagem de rolagem em vez de uma lista suspensa
de uma única linha.

func (*TagInputEMail) Name 

func (e *TagInputEMail) Name(name string) (ref *TagInputEMail)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputEMail) Nonce 

func (e *TagInputEMail) Nonce(part ...string) (ref *TagInputEMail)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputEMail) ReadOnly 

func (e *TagInputEMail) ReadOnly(readonly bool) (ref *TagInputEMail)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputEMail) Required 

func (e *TagInputEMail) Required(required bool) (ref *TagInputEMail)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputEMail) SetX 

func (e *TagInputEMail) SetX(x int) (ref *TagInputEMail)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputEMail) SetXY 

func (e *TagInputEMail) SetXY(x, y int) (ref *TagInputEMail)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputEMail) SetY 

func (e *TagInputEMail) SetY(y int) (ref *TagInputEMail)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputEMail) Size 

func (e *TagInputEMail) Size(size int) (ref *TagInputEMail)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputEMail) Slot 

func (e *TagInputEMail) Slot(slot string) (ref *TagInputEMail)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputEMail) Spellcheck 

func (e *TagInputEMail) Spellcheck(spell bool) (ref *TagInputEMail)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputEMail) Style 

func (e *TagInputEMail) Style(style string) (ref *TagInputEMail)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputEMail) TabIndex 

func (e *TagInputEMail) TabIndex(index int) (ref *TagInputEMail)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputEMail) Title 

func (e *TagInputEMail) Title(title string) (ref *TagInputEMail)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputEMail) Translate 

func (e *TagInputEMail) Translate(translate Translate) (ref *TagInputEMail)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputEMail) Type 

func (e *TagInputEMail) Type(inputType InputType) (ref *TagInputEMail)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputEMail) Value 

func (e *TagInputEMail) Value(value string) (ref *TagInputEMail)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputFile 

type TagInputFile struct {
	// contains filtered or unexported fields
}

func (*TagInputFile) Accept 

func (e *TagInputFile) Accept(accept string) (ref *TagInputFile)

Accept

English: 

Valid for the file input type only, the accept attribute defines which file types are selectable
in a file upload control. See the file input type.

Português: 

Válido apenas para o tipo de entrada de arquivo, o atributo accept define quais tipos de arquivo
são selecionáveis em um controle de upload de arquivo. Consulte o tipo de entrada do arquivo.

func (*TagInputFile) AccessKey 

func (e *TagInputFile) AccessKey(key string) (ref *TagInputFile)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputFile) Append 

func (e *TagInputFile) Append(append interface{}) (ref *TagInputFile)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputFile) AppendById 

func (e *TagInputFile) AppendById(appendId string) (ref *TagInputFile)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputFile) Autocomplete 

func (e *TagInputFile) Autocomplete(autocomplete Autocomplete) (ref *TagInputFile)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputFile) Autofocus 

func (e *TagInputFile) Autofocus(autofocus bool) (ref *TagInputFile)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputFile) Capture 

func (e *TagInputFile) Capture(capture string) (ref *TagInputFile)

Capture

English: 

Introduced in the HTML Media Capture specification and valid for the file input type only, the
capture attribute defines which media—microphone, video, or camera—should be used to capture a
new file for upload with file upload control in supporting scenarios.

Português: 

Introduzido na especificação HTML Media Capture e válido apenas para o tipo de entrada de arquivo,
o atributo capture define qual mídia—microfone, vídeo ou câmera—deve ser usada para capturar um
novo arquivo para upload com controle de upload de arquivo em cenários de suporte.

func (*TagInputFile) Class 

func (e *TagInputFile) Class(class ...string) (ref *TagInputFile)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputFile) ContentEditable 

func (e *TagInputFile) ContentEditable(editable bool) (ref *TagInputFile)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputFile) CreateElement 

func (e *TagInputFile) CreateElement(tag Tag) (ref *TagInputFile)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputFile) Data 

func (e *TagInputFile) Data(data map[string]string) (ref *TagInputFile)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputFile) Dir 

func (e *TagInputFile) Dir(dir Dir) (ref *TagInputFile)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputFile) Disabled 

func (e *TagInputFile) Disabled(disabled bool) (ref *TagInputFile)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputFile) Draggable 

func (e *TagInputFile) Draggable(draggable Draggable) (ref *TagInputFile)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputFile) EnterKeyHint 

func (e *TagInputFile) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputFile)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputFile) Form 

func (e *TagInputFile) Form(form string) (ref *TagInputFile)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputFile) GetX 

func (e *TagInputFile) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputFile) GetXY 

func (e *TagInputFile) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputFile) GetY 

func (e *TagInputFile) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputFile) Hidden 

func (e *TagInputFile) Hidden() (ref *TagInputFile)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputFile) Id 

func (e *TagInputFile) Id(id string) (ref *TagInputFile)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputFile) InputMode 

func (e *TagInputFile) InputMode(inputMode InputMode) (ref *TagInputFile)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputFile) Is 

func (e *TagInputFile) Is(is string) (ref *TagInputFile)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputFile) ItemDrop 

func (e *TagInputFile) ItemDrop(itemprop string) (ref *TagInputFile)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputFile) ItemId 

func (e *TagInputFile) ItemId(id string) (ref *TagInputFile)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputFile) ItemRef 

func (e *TagInputFile) ItemRef(itemref string) (ref *TagInputFile)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputFile) ItemType 

func (e *TagInputFile) ItemType(itemType string) (ref *TagInputFile)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputFile) Lang 

func (e *TagInputFile) Lang(language Language) (ref *TagInputFile)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputFile) List 

func (e *TagInputFile) List(list string) (ref *TagInputFile)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputFile) Multiple 

func (e *TagInputFile) Multiple(multiple bool) (ref *TagInputFile)

Multiple

English: 

This Boolean attribute indicates that multiple options can be selected in the list. If it is not
specified, then only one option can be selected at a time. When multiple is specified, most
browsers will show a scrolling list box instead of a single line dropdown.

Português: 

Este atributo booleano indica que várias opções podem ser selecionadas na lista. Se não for
especificado, apenas uma opção pode ser selecionada por vez. Quando vários são especificados, a
maioria dos navegadores mostrará uma caixa de listagem de rolagem em vez de uma lista suspensa
de uma única linha.

func (*TagInputFile) Name 

func (e *TagInputFile) Name(name string) (ref *TagInputFile)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputFile) Nonce 

func (e *TagInputFile) Nonce(part ...string) (ref *TagInputFile)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputFile) ReadOnly 

func (e *TagInputFile) ReadOnly(readonly bool) (ref *TagInputFile)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputFile) Required 

func (e *TagInputFile) Required(required bool) (ref *TagInputFile)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputFile) SetX 

func (e *TagInputFile) SetX(x int) (ref *TagInputFile)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputFile) SetXY 

func (e *TagInputFile) SetXY(x, y int) (ref *TagInputFile)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputFile) SetY 

func (e *TagInputFile) SetY(y int) (ref *TagInputFile)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputFile) Slot 

func (e *TagInputFile) Slot(slot string) (ref *TagInputFile)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputFile) Spellcheck 

func (e *TagInputFile) Spellcheck(spell bool) (ref *TagInputFile)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputFile) Style 

func (e *TagInputFile) Style(style string) (ref *TagInputFile)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputFile) TabIndex 

func (e *TagInputFile) TabIndex(index int) (ref *TagInputFile)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputFile) Title 

func (e *TagInputFile) Title(title string) (ref *TagInputFile)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputFile) Translate 

func (e *TagInputFile) Translate(translate Translate) (ref *TagInputFile)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputFile) Type 

func (e *TagInputFile) Type(inputType InputType) (ref *TagInputFile)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputFile) Value 

func (e *TagInputFile) Value(value string) (ref *TagInputFile)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputHidden 

type TagInputHidden struct {
	// contains filtered or unexported fields
}

func (*TagInputHidden) AccessKey 

func (e *TagInputHidden) AccessKey(key string) (ref *TagInputHidden)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputHidden) Append 

func (e *TagInputHidden) Append(append interface{}) (ref *TagInputHidden)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputHidden) AppendById 

func (e *TagInputHidden) AppendById(appendId string) (ref *TagInputHidden)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputHidden) Autocomplete 

func (e *TagInputHidden) Autocomplete(autocomplete Autocomplete) (ref *TagInputHidden)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputHidden) Autofocus 

func (e *TagInputHidden) Autofocus(autofocus bool) (ref *TagInputHidden)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputHidden) Class 

func (e *TagInputHidden) Class(class ...string) (ref *TagInputHidden)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputHidden) ContentEditable 

func (e *TagInputHidden) ContentEditable(editable bool) (ref *TagInputHidden)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputHidden) CreateElement 

func (e *TagInputHidden) CreateElement(tag Tag) (ref *TagInputHidden)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputHidden) Data 

func (e *TagInputHidden) Data(data map[string]string) (ref *TagInputHidden)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputHidden) Dir 

func (e *TagInputHidden) Dir(dir Dir) (ref *TagInputHidden)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputHidden) Disabled 

func (e *TagInputHidden) Disabled(disabled bool) (ref *TagInputHidden)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputHidden) Draggable 

func (e *TagInputHidden) Draggable(draggable Draggable) (ref *TagInputHidden)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputHidden) EnterKeyHint 

func (e *TagInputHidden) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputHidden)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputHidden) Form 

func (e *TagInputHidden) Form(form string) (ref *TagInputHidden)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputHidden) GetX 

func (e *TagInputHidden) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputHidden) GetXY 

func (e *TagInputHidden) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputHidden) GetY 

func (e *TagInputHidden) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputHidden) Hidden 

func (e *TagInputHidden) Hidden() (ref *TagInputHidden)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputHidden) Id 

func (e *TagInputHidden) Id(id string) (ref *TagInputHidden)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputHidden) InputMode 

func (e *TagInputHidden) InputMode(inputMode InputMode) (ref *TagInputHidden)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputHidden) Is 

func (e *TagInputHidden) Is(is string) (ref *TagInputHidden)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputHidden) ItemDrop 

func (e *TagInputHidden) ItemDrop(itemprop string) (ref *TagInputHidden)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputHidden) ItemId 

func (e *TagInputHidden) ItemId(id string) (ref *TagInputHidden)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputHidden) ItemRef 

func (e *TagInputHidden) ItemRef(itemref string) (ref *TagInputHidden)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputHidden) ItemType 

func (e *TagInputHidden) ItemType(itemType string) (ref *TagInputHidden)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputHidden) Lang 

func (e *TagInputHidden) Lang(language Language) (ref *TagInputHidden)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputHidden) List 

func (e *TagInputHidden) List(list string) (ref *TagInputHidden)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputHidden) Min 

func (e *TagInputHidden) Min(min int) (ref *TagInputHidden)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputHidden) Name 

func (e *TagInputHidden) Name(name string) (ref *TagInputHidden)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputHidden) Nonce 

func (e *TagInputHidden) Nonce(part ...string) (ref *TagInputHidden)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputHidden) ReadOnly 

func (e *TagInputHidden) ReadOnly(readonly bool) (ref *TagInputHidden)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputHidden) Required 

func (e *TagInputHidden) Required(required bool) (ref *TagInputHidden)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputHidden) SetX 

func (e *TagInputHidden) SetX(x int) (ref *TagInputHidden)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputHidden) SetXY 

func (e *TagInputHidden) SetXY(x, y int) (ref *TagInputHidden)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputHidden) SetY 

func (e *TagInputHidden) SetY(y int) (ref *TagInputHidden)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputHidden) Slot 

func (e *TagInputHidden) Slot(slot string) (ref *TagInputHidden)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputHidden) Spellcheck 

func (e *TagInputHidden) Spellcheck(spell bool) (ref *TagInputHidden)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputHidden) Style 

func (e *TagInputHidden) Style(style string) (ref *TagInputHidden)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputHidden) TabIndex 

func (e *TagInputHidden) TabIndex(index int) (ref *TagInputHidden)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputHidden) Title 

func (e *TagInputHidden) Title(title string) (ref *TagInputHidden)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputHidden) Translate 

func (e *TagInputHidden) Translate(translate Translate) (ref *TagInputHidden)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputHidden) Type 

func (e *TagInputHidden) Type(inputType InputType) (ref *TagInputHidden)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputHidden) Value 

func (e *TagInputHidden) Value(value string) (ref *TagInputHidden)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputImage 

type TagInputImage struct {
	// contains filtered or unexported fields
}

func (*TagInputImage) AccessKey 

func (e *TagInputImage) AccessKey(key string) (ref *TagInputImage)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputImage) Alt 

func (e *TagInputImage) Alt(alt string) (ref *TagInputImage)

Alt

English: 

The alt attribute provides alternative text for the image, displaying the value of the attribute
if the image src is missing or otherwise fails to load.

Português: 

O atributo alt fornece texto alternativo para a imagem, exibindo o valor do atributo se o src da
imagem estiver ausente ou falhar ao carregar.

func (*TagInputImage) Append 

func (e *TagInputImage) Append(append interface{}) (ref *TagInputImage)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputImage) AppendById 

func (e *TagInputImage) AppendById(appendId string) (ref *TagInputImage)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputImage) Autocomplete 

func (e *TagInputImage) Autocomplete(autocomplete Autocomplete) (ref *TagInputImage)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputImage) Autofocus 

func (e *TagInputImage) Autofocus(autofocus bool) (ref *TagInputImage)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputImage) Class 

func (e *TagInputImage) Class(class ...string) (ref *TagInputImage)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputImage) ContentEditable 

func (e *TagInputImage) ContentEditable(editable bool) (ref *TagInputImage)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputImage) CreateElement 

func (e *TagInputImage) CreateElement(tag Tag) (ref *TagInputImage)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputImage) Data 

func (e *TagInputImage) Data(data map[string]string) (ref *TagInputImage)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputImage) Dir 

func (e *TagInputImage) Dir(dir Dir) (ref *TagInputImage)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputImage) Disabled 

func (e *TagInputImage) Disabled(disabled bool) (ref *TagInputImage)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputImage) Draggable 

func (e *TagInputImage) Draggable(draggable Draggable) (ref *TagInputImage)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputImage) EnterKeyHint 

func (e *TagInputImage) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputImage)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputImage) Form 

func (e *TagInputImage) Form(form string) (ref *TagInputImage)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputImage) FormAction 

func (e *TagInputImage) FormAction(action string) (ref *TagInputImage)

FormAction

English: 

A string indicating the URL to which to submit the data. This takes precedence over the action
attribute on the <form> element that owns the <input>.

This attribute is also available on <input type="image"> and <button> elements.

Português: 

Uma string indicando o URL para o qual enviar os dados. Isso tem precedência sobre o atributo
action no elemento <form> que possui o <input>.

Este atributo também está disponível nos elementos <input type="image"> e <button>.

func (*TagInputImage) FormEncType 

func (e *TagInputImage) FormEncType(formenctype FormEncType) (ref *TagInputImage)

FormEncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagInputImage) FormMethod 

func (e *TagInputImage) FormMethod(method FormMethod) (ref *TagInputImage)

FormMethod

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials.
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login.
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagInputImage) FormTarget 

func (e *TagInputImage) FormTarget(formtarget Target) (ref *TagInputImage)

FormTarget

English: 

If the button is a submit button, this attribute is an author-defined name or standardized,
underscore-prefixed keyword indicating where to display the response from submitting the form.

This is the name of, or keyword for, a browsing context (a tab, window, or <iframe>). If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Português: 

Se o botão for um botão de envio, esse atributo será um nome definido pelo autor ou uma
palavra-chave padronizada com prefixo de sublinhado indicando onde exibir a resposta do envio do
formulário.

Este é o nome ou a palavra-chave de um contexto de navegação (uma guia, janela ou <iframe>). Se este atributo for especificado, ele substituirá o atributo de destino do proprietário do formulário do botão. As seguintes palavras-chave têm significados especiais: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

func (*TagInputImage) FormValidate 

func (e *TagInputImage) FormValidate(validate bool) (ref *TagInputImage)

FormValidate

English: 

If the button is a submit button, 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.

Português: 

Se o botão for um botão de envio, este atributo booleano especifica que o formulário não deve ser
validado quando for enviado.

Se este atributo for especificado, ele substituirá o atributo novalidate do proprietário do formulário do botão.

func (*TagInputImage) GetX 

func (e *TagInputImage) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputImage) GetXY 

func (e *TagInputImage) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputImage) GetY 

func (e *TagInputImage) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputImage) Height 

func (e *TagInputImage) Height(height int) (ref *TagInputImage)

Height

English: 

The height is the height of the image file to display to represent the graphical submit button.

Português: 

A altura é a altura do arquivo de imagem a ser exibido para representar o botão de envio gráfico.

func (*TagInputImage) Hidden 

func (e *TagInputImage) Hidden() (ref *TagInputImage)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputImage) Id 

func (e *TagInputImage) Id(id string) (ref *TagInputImage)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputImage) InputMode 

func (e *TagInputImage) InputMode(inputMode InputMode) (ref *TagInputImage)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputImage) Is 

func (e *TagInputImage) Is(is string) (ref *TagInputImage)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputImage) ItemDrop 

func (e *TagInputImage) ItemDrop(itemprop string) (ref *TagInputImage)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputImage) ItemId 

func (e *TagInputImage) ItemId(id string) (ref *TagInputImage)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputImage) ItemRef 

func (e *TagInputImage) ItemRef(itemref string) (ref *TagInputImage)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputImage) ItemType 

func (e *TagInputImage) ItemType(itemType string) (ref *TagInputImage)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputImage) Lang 

func (e *TagInputImage) Lang(language Language) (ref *TagInputImage)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputImage) List 

func (e *TagInputImage) List(list string) (ref *TagInputImage)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputImage) Name 

func (e *TagInputImage) Name(name string) (ref *TagInputImage)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputImage) Nonce 

func (e *TagInputImage) Nonce(part ...string) (ref *TagInputImage)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputImage) ReadOnly 

func (e *TagInputImage) ReadOnly(readonly bool) (ref *TagInputImage)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputImage) Required 

func (e *TagInputImage) Required(required bool) (ref *TagInputImage)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputImage) SetX 

func (e *TagInputImage) SetX(x int) (ref *TagInputImage)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputImage) SetXY 

func (e *TagInputImage) SetXY(x, y int) (ref *TagInputImage)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputImage) SetY 

func (e *TagInputImage) SetY(y int) (ref *TagInputImage)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputImage) Slot 

func (e *TagInputImage) Slot(slot string) (ref *TagInputImage)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputImage) Spellcheck 

func (e *TagInputImage) Spellcheck(spell bool) (ref *TagInputImage)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputImage) Src 

func (e *TagInputImage) Src(src string) (ref *TagInputImage)

Src

English: 

Valid for the image input button only, the src is string specifying the URL of the image file to
display to represent the graphical submit button.

Português: 

Válido apenas para o botão de entrada de imagem, o src é uma string que especifica a URL do
arquivo de imagem a ser exibido para representar o botão de envio gráfico.

func (*TagInputImage) Style 

func (e *TagInputImage) Style(style string) (ref *TagInputImage)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputImage) TabIndex 

func (e *TagInputImage) TabIndex(index int) (ref *TagInputImage)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputImage) Title 

func (e *TagInputImage) Title(title string) (ref *TagInputImage)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputImage) Translate 

func (e *TagInputImage) Translate(translate Translate) (ref *TagInputImage)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputImage) Type 

func (e *TagInputImage) Type(inputType InputType) (ref *TagInputImage)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputImage) Value 

func (e *TagInputImage) Value(value string) (ref *TagInputImage)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

func (*TagInputImage) Width 

func (e *TagInputImage) Width(width int) (ref *TagInputImage)

Width

English: 

Valid for the image input button only, the width is the width of the image file to display to
represent the graphical submit button. See the image input type.

Português: 

Válido apenas para o botão de entrada de imagem, a largura é a largura do arquivo de imagem a
ser exibido para representar o botão de envio gráfico. Consulte o tipo de entrada de imagem.

type TagInputMonth 

type TagInputMonth struct {
	// contains filtered or unexported fields
}

func (*TagInputMonth) AccessKey 

func (e *TagInputMonth) AccessKey(key string) (ref *TagInputMonth)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputMonth) Append 

func (e *TagInputMonth) Append(append interface{}) (ref *TagInputMonth)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputMonth) AppendById 

func (e *TagInputMonth) AppendById(appendId string) (ref *TagInputMonth)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputMonth) Autocomplete 

func (e *TagInputMonth) Autocomplete(autocomplete Autocomplete) (ref *TagInputMonth)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputMonth) Autofocus 

func (e *TagInputMonth) Autofocus(autofocus bool) (ref *TagInputMonth)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputMonth) Class 

func (e *TagInputMonth) Class(class ...string) (ref *TagInputMonth)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputMonth) ContentEditable 

func (e *TagInputMonth) ContentEditable(editable bool) (ref *TagInputMonth)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputMonth) CreateElement 

func (e *TagInputMonth) CreateElement(tag Tag) (ref *TagInputMonth)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputMonth) Data 

func (e *TagInputMonth) Data(data map[string]string) (ref *TagInputMonth)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputMonth) Dir 

func (e *TagInputMonth) Dir(dir Dir) (ref *TagInputMonth)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputMonth) Disabled 

func (e *TagInputMonth) Disabled(disabled bool) (ref *TagInputMonth)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputMonth) Draggable 

func (e *TagInputMonth) Draggable(draggable Draggable) (ref *TagInputMonth)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputMonth) EnterKeyHint 

func (e *TagInputMonth) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputMonth)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputMonth) Form 

func (e *TagInputMonth) Form(form string) (ref *TagInputMonth)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputMonth) GetX 

func (e *TagInputMonth) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputMonth) GetXY 

func (e *TagInputMonth) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputMonth) GetY 

func (e *TagInputMonth) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputMonth) Hidden 

func (e *TagInputMonth) Hidden() (ref *TagInputMonth)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputMonth) Id 

func (e *TagInputMonth) Id(id string) (ref *TagInputMonth)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputMonth) InputMode 

func (e *TagInputMonth) InputMode(inputMode InputMode) (ref *TagInputMonth)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputMonth) Is 

func (e *TagInputMonth) Is(is string) (ref *TagInputMonth)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputMonth) ItemDrop 

func (e *TagInputMonth) ItemDrop(itemprop string) (ref *TagInputMonth)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputMonth) ItemId 

func (e *TagInputMonth) ItemId(id string) (ref *TagInputMonth)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputMonth) ItemRef 

func (e *TagInputMonth) ItemRef(itemref string) (ref *TagInputMonth)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputMonth) ItemType 

func (e *TagInputMonth) ItemType(itemType string) (ref *TagInputMonth)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputMonth) Lang 

func (e *TagInputMonth) Lang(language Language) (ref *TagInputMonth)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputMonth) List 

func (e *TagInputMonth) List(list string) (ref *TagInputMonth)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputMonth) Max 

func (e *TagInputMonth) Max(max int) (ref *TagInputMonth)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputMonth) Min 

func (e *TagInputMonth) Min(min int) (ref *TagInputMonth)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputMonth) Name 

func (e *TagInputMonth) Name(name string) (ref *TagInputMonth)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputMonth) Nonce 

func (e *TagInputMonth) Nonce(part ...string) (ref *TagInputMonth)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputMonth) ReadOnly 

func (e *TagInputMonth) ReadOnly(readonly bool) (ref *TagInputMonth)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputMonth) Required 

func (e *TagInputMonth) Required(required bool) (ref *TagInputMonth)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputMonth) SetX 

func (e *TagInputMonth) SetX(x int) (ref *TagInputMonth)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputMonth) SetXY 

func (e *TagInputMonth) SetXY(x, y int) (ref *TagInputMonth)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputMonth) SetY 

func (e *TagInputMonth) SetY(y int) (ref *TagInputMonth)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputMonth) Slot 

func (e *TagInputMonth) Slot(slot string) (ref *TagInputMonth)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputMonth) Spellcheck 

func (e *TagInputMonth) Spellcheck(spell bool) (ref *TagInputMonth)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputMonth) Step 

func (e *TagInputMonth) Step(step int) (ref *TagInputMonth)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputMonth) Style 

func (e *TagInputMonth) Style(style string) (ref *TagInputMonth)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputMonth) TabIndex 

func (e *TagInputMonth) TabIndex(index int) (ref *TagInputMonth)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputMonth) Title 

func (e *TagInputMonth) Title(title string) (ref *TagInputMonth)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputMonth) Translate 

func (e *TagInputMonth) Translate(translate Translate) (ref *TagInputMonth)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputMonth) Type 

func (e *TagInputMonth) Type(inputType InputType) (ref *TagInputMonth)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputMonth) Value 

func (e *TagInputMonth) Value(value string) (ref *TagInputMonth)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputNumber 

type TagInputNumber struct {
	// contains filtered or unexported fields
}

func (*TagInputNumber) AccessKey 

func (e *TagInputNumber) AccessKey(key string) (ref *TagInputNumber)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputNumber) Append 

func (e *TagInputNumber) Append(append interface{}) (ref *TagInputNumber)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputNumber) AppendById 

func (e *TagInputNumber) AppendById(appendId string) (ref *TagInputNumber)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputNumber) Autocomplete 

func (e *TagInputNumber) Autocomplete(autocomplete Autocomplete) (ref *TagInputNumber)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputNumber) Autofocus 

func (e *TagInputNumber) Autofocus(autofocus bool) (ref *TagInputNumber)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputNumber) Class 

func (e *TagInputNumber) Class(class ...string) (ref *TagInputNumber)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputNumber) ContentEditable 

func (e *TagInputNumber) ContentEditable(editable bool) (ref *TagInputNumber)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputNumber) CreateElement 

func (e *TagInputNumber) CreateElement(tag Tag) (ref *TagInputNumber)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputNumber) Data 

func (e *TagInputNumber) Data(data map[string]string) (ref *TagInputNumber)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputNumber) Dir 

func (e *TagInputNumber) Dir(dir Dir) (ref *TagInputNumber)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputNumber) Disabled 

func (e *TagInputNumber) Disabled(disabled bool) (ref *TagInputNumber)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputNumber) Draggable 

func (e *TagInputNumber) Draggable(draggable Draggable) (ref *TagInputNumber)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputNumber) EnterKeyHint 

func (e *TagInputNumber) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputNumber)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputNumber) Form 

func (e *TagInputNumber) Form(form string) (ref *TagInputNumber)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputNumber) GetX 

func (e *TagInputNumber) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputNumber) GetXY 

func (e *TagInputNumber) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputNumber) GetY 

func (e *TagInputNumber) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputNumber) Hidden 

func (e *TagInputNumber) Hidden() (ref *TagInputNumber)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputNumber) Id 

func (e *TagInputNumber) Id(id string) (ref *TagInputNumber)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputNumber) InputMode 

func (e *TagInputNumber) InputMode(inputMode InputMode) (ref *TagInputNumber)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputNumber) Is 

func (e *TagInputNumber) Is(is string) (ref *TagInputNumber)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputNumber) ItemDrop 

func (e *TagInputNumber) ItemDrop(itemprop string) (ref *TagInputNumber)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputNumber) ItemId 

func (e *TagInputNumber) ItemId(id string) (ref *TagInputNumber)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputNumber) ItemRef 

func (e *TagInputNumber) ItemRef(itemref string) (ref *TagInputNumber)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputNumber) ItemType 

func (e *TagInputNumber) ItemType(itemType string) (ref *TagInputNumber)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputNumber) Lang 

func (e *TagInputNumber) Lang(language Language) (ref *TagInputNumber)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputNumber) List 

func (e *TagInputNumber) List(list string) (ref *TagInputNumber)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputNumber) Max 

func (e *TagInputNumber) Max(max int) (ref *TagInputNumber)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputNumber) Min 

func (e *TagInputNumber) Min(min int) (ref *TagInputNumber)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputNumber) Name 

func (e *TagInputNumber) Name(name string) (ref *TagInputNumber)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputNumber) Nonce 

func (e *TagInputNumber) Nonce(part ...string) (ref *TagInputNumber)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputNumber) ReadOnly 

func (e *TagInputNumber) ReadOnly(readonly bool) (ref *TagInputNumber)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputNumber) Required 

func (e *TagInputNumber) Required(required bool) (ref *TagInputNumber)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputNumber) SetX 

func (e *TagInputNumber) SetX(x int) (ref *TagInputNumber)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputNumber) SetXY 

func (e *TagInputNumber) SetXY(x, y int) (ref *TagInputNumber)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputNumber) SetY 

func (e *TagInputNumber) SetY(y int) (ref *TagInputNumber)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputNumber) Slot 

func (e *TagInputNumber) Slot(slot string) (ref *TagInputNumber)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputNumber) Spellcheck 

func (e *TagInputNumber) Spellcheck(spell bool) (ref *TagInputNumber)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputNumber) Step 

func (e *TagInputNumber) Step(step int) (ref *TagInputNumber)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputNumber) Style 

func (e *TagInputNumber) Style(style string) (ref *TagInputNumber)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputNumber) TabIndex 

func (e *TagInputNumber) TabIndex(index int) (ref *TagInputNumber)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputNumber) Title 

func (e *TagInputNumber) Title(title string) (ref *TagInputNumber)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputNumber) Translate 

func (e *TagInputNumber) Translate(translate Translate) (ref *TagInputNumber)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputNumber) Type 

func (e *TagInputNumber) Type(inputType InputType) (ref *TagInputNumber)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputNumber) Value 

func (e *TagInputNumber) Value(value string) (ref *TagInputNumber)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputPassword 

type TagInputPassword struct {
	// contains filtered or unexported fields
}

func (*TagInputPassword) AccessKey 

func (e *TagInputPassword) AccessKey(key string) (ref *TagInputPassword)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputPassword) Append 

func (e *TagInputPassword) Append(append interface{}) (ref *TagInputPassword)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputPassword) AppendById 

func (e *TagInputPassword) AppendById(appendId string) (ref *TagInputPassword)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputPassword) Autocomplete 

func (e *TagInputPassword) Autocomplete(autocomplete Autocomplete) (ref *TagInputPassword)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputPassword) Autofocus 

func (e *TagInputPassword) Autofocus(autofocus bool) (ref *TagInputPassword)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputPassword) Class 

func (e *TagInputPassword) Class(class ...string) (ref *TagInputPassword)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputPassword) ContentEditable 

func (e *TagInputPassword) ContentEditable(editable bool) (ref *TagInputPassword)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputPassword) CreateElement 

func (e *TagInputPassword) CreateElement(tag Tag) (ref *TagInputPassword)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputPassword) Data 

func (e *TagInputPassword) Data(data map[string]string) (ref *TagInputPassword)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputPassword) Dir 

func (e *TagInputPassword) Dir(dir Dir) (ref *TagInputPassword)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputPassword) Disabled 

func (e *TagInputPassword) Disabled(disabled bool) (ref *TagInputPassword)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputPassword) Draggable 

func (e *TagInputPassword) Draggable(draggable Draggable) (ref *TagInputPassword)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputPassword) EnterKeyHint 

func (e *TagInputPassword) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputPassword)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputPassword) Form 

func (e *TagInputPassword) Form(form string) (ref *TagInputPassword)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputPassword) GetX 

func (e *TagInputPassword) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputPassword) GetXY 

func (e *TagInputPassword) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputPassword) GetY 

func (e *TagInputPassword) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputPassword) Hidden 

func (e *TagInputPassword) Hidden() (ref *TagInputPassword)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputPassword) Id 

func (e *TagInputPassword) Id(id string) (ref *TagInputPassword)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputPassword) InputMode 

func (e *TagInputPassword) InputMode(inputMode InputMode) (ref *TagInputPassword)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputPassword) Is 

func (e *TagInputPassword) Is(is string) (ref *TagInputPassword)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputPassword) ItemDrop 

func (e *TagInputPassword) ItemDrop(itemprop string) (ref *TagInputPassword)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputPassword) ItemId 

func (e *TagInputPassword) ItemId(id string) (ref *TagInputPassword)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputPassword) ItemRef 

func (e *TagInputPassword) ItemRef(itemref string) (ref *TagInputPassword)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputPassword) ItemType 

func (e *TagInputPassword) ItemType(itemType string) (ref *TagInputPassword)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputPassword) Lang 

func (e *TagInputPassword) Lang(language Language) (ref *TagInputPassword)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputPassword) List 

func (e *TagInputPassword) List(list string) (ref *TagInputPassword)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputPassword) MaxLength 

func (e *TagInputPassword) MaxLength(maxlength int) (ref *TagInputPassword)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputPassword) MinLength 

func (e *TagInputPassword) MinLength(minlength int) (ref *TagInputPassword)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputPassword) Name 

func (e *TagInputPassword) Name(name string) (ref *TagInputPassword)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputPassword) Nonce 

func (e *TagInputPassword) Nonce(part ...string) (ref *TagInputPassword)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputPassword) Pattern 

func (e *TagInputPassword) Pattern(pattern string) (ref *TagInputPassword)

Pattern

English: 

The pattern attribute, when specified, is a regular expression that the input's value must match
in order for the value to pass constraint validation. It must be a valid JavaScript regular
expression, as used by the RegExp type, and as documented in our guide on regular expressions;
the 'u' flag is specified when compiling the regular expression, so that the pattern is treated
as a sequence of Unicode code points, instead of as ASCII. No forward slashes should be specified
around the pattern text.

If the pattern attribute is present but is not specified or is invalid, no regular expression is applied and this attribute is ignored completely. If the pattern attribute is valid and a non-empty value does not match the pattern, constraint validation will prevent form submission. 

Note:
  * If using the pattern attribute, inform the user about the expected format by including
    explanatory text nearby. You can also include a title attribute to explain what the
    requirements are to match the pattern; most browsers will display this title as a tooltip.
    The visible explanation is required for accessibility. The tooltip is an enhancement.

Português: 

O atributo pattern, quando especificado, é uma expressão regular que o valor da entrada deve
corresponder para que o valor passe na validação de restrição. Deve ser uma expressão regular
JavaScript válida, conforme usada pelo tipo RegExp e conforme documentado em nosso guia sobre
expressões regulares; o sinalizador 'u' é especificado ao compilar a expressão regular, para que
o padrão seja tratado como uma sequência de pontos de código Unicode, em vez de como ASCII.
Nenhuma barra deve ser especificada ao redor do texto do padrão.

Se o atributo pattern estiver presente, mas não for especificado ou for inválido, nenhuma expressão regular será aplicada e esse atributo será completamente ignorado. Se o atributo de padrão for válido e um valor não vazio não corresponder ao padrão, a validação de restrição impedirá o envio do formulário. 

Nota:
  * Se estiver usando o atributo pattern, informe o usuário sobre o formato esperado incluindo
    um texto explicativo próximo. Você também pode incluir um atributo title para explicar quais
    são os requisitos para corresponder ao padrão; a maioria dos navegadores exibirá este título
    como uma dica de ferramenta. A explicação visível é necessária para acessibilidade. A dica
    de ferramenta é um aprimoramento.

func (*TagInputPassword) Placeholder 

func (e *TagInputPassword) Placeholder(placeholder string) (ref *TagInputPassword)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputPassword) ReadOnly 

func (e *TagInputPassword) ReadOnly(readonly bool) (ref *TagInputPassword)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputPassword) Required 

func (e *TagInputPassword) Required(required bool) (ref *TagInputPassword)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputPassword) SetX 

func (e *TagInputPassword) SetX(x int) (ref *TagInputPassword)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputPassword) SetXY 

func (e *TagInputPassword) SetXY(x, y int) (ref *TagInputPassword)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputPassword) SetY 

func (e *TagInputPassword) SetY(y int) (ref *TagInputPassword)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputPassword) Size 

func (e *TagInputPassword) Size(size int) (ref *TagInputPassword)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputPassword) Slot 

func (e *TagInputPassword) Slot(slot string) (ref *TagInputPassword)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputPassword) Spellcheck 

func (e *TagInputPassword) Spellcheck(spell bool) (ref *TagInputPassword)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputPassword) Style 

func (e *TagInputPassword) Style(style string) (ref *TagInputPassword)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputPassword) TabIndex 

func (e *TagInputPassword) TabIndex(index int) (ref *TagInputPassword)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputPassword) Title 

func (e *TagInputPassword) Title(title string) (ref *TagInputPassword)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputPassword) Translate 

func (e *TagInputPassword) Translate(translate Translate) (ref *TagInputPassword)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputPassword) Type 

func (e *TagInputPassword) Type(inputType InputType) (ref *TagInputPassword)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputPassword) Value 

func (e *TagInputPassword) Value(value string) (ref *TagInputPassword)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputRadio 

type TagInputRadio struct {
	// contains filtered or unexported fields
}

func (*TagInputRadio) AccessKey 

func (e *TagInputRadio) AccessKey(key string) (ref *TagInputRadio)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputRadio) Append 

func (e *TagInputRadio) Append(append interface{}) (ref *TagInputRadio)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRadio) AppendById 

func (e *TagInputRadio) AppendById(appendId string) (ref *TagInputRadio)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRadio) Autocomplete 

func (e *TagInputRadio) Autocomplete(autocomplete Autocomplete) (ref *TagInputRadio)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputRadio) Autofocus 

func (e *TagInputRadio) Autofocus(autofocus bool) (ref *TagInputRadio)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputRadio) Checked 

func (e *TagInputRadio) Checked(checked bool) (ref *TagInputRadio)

Checked

English: 

Valid for both radio and checkbox types, checked is a Boolean attribute. If present on a radio
type, it indicates that the radio button is the currently selected one in the group of same-named
radio buttons. If present on a checkbox type, it indicates that the checkbox is checked by default
(when the page loads).
It does not indicate whether this checkbox is currently checked: if the checkbox's state is
changed, this content attribute does not reflect the change.
(Only the HTMLInputElement's checked IDL attribute is updated.)

 Note:
   * Unlike other input controls, a checkboxes and radio buttons value are only included in the
     submitted data if they are currently checked. If they are, the name and the value(s) of the
     checked controls are submitted.
     For example, if a checkbox whose name is fruit has a value of cherry, and the checkbox is
     checked, the form data submitted will include fruit=cherry. If the checkbox isn't active,
     it isn't listed in the form data at all. The default value for checkboxes and radio buttons
     is on.

Português: 

Válido para os tipos de rádio e caixa de seleção, marcado é um atributo booleano. Se estiver
presente em um tipo de rádio, indica que o botão de opção é o selecionado atualmente no grupo de
botões de opção com o mesmo nome. Se estiver presente em um tipo de caixa de seleção, indica que
a caixa de seleção está marcada por padrão (quando a página é carregada). Não indica se esta caixa
de seleção está marcada no momento: se o estado da caixa de seleção for alterado, esse atributo
de conteúdo não reflete a alteração.
(Apenas o atributo IDL verificado do HTMLInputElement é atualizado.)

 Nota:
   * Ao contrário de outros controles de entrada, um valor de caixas de seleção e botões de opção
     só são incluídos nos dados enviados se estiverem marcados no momento. Se estiverem, o nome e
     o(s) valor(es) dos controles verificados são enviados.
     Por exemplo, se uma caixa de seleção cujo nome é fruta tiver o valor cereja e a caixa de
     seleção estiver marcada, os dados do formulário enviados incluirão fruta=cereja.
     Se a caixa de seleção não estiver ativa, ela não está listada nos dados do formulário.
     O valor padrão para caixas de seleção e botões de opção é ativado.

func (*TagInputRadio) Class 

func (e *TagInputRadio) Class(class ...string) (ref *TagInputRadio)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputRadio) ContentEditable 

func (e *TagInputRadio) ContentEditable(editable bool) (ref *TagInputRadio)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputRadio) CreateElement 

func (e *TagInputRadio) CreateElement(tag Tag) (ref *TagInputRadio)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputRadio) Data 

func (e *TagInputRadio) Data(data map[string]string) (ref *TagInputRadio)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputRadio) Dir 

func (e *TagInputRadio) Dir(dir Dir) (ref *TagInputRadio)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputRadio) Disabled 

func (e *TagInputRadio) Disabled(disabled bool) (ref *TagInputRadio)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputRadio) Draggable 

func (e *TagInputRadio) Draggable(draggable Draggable) (ref *TagInputRadio)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputRadio) EnterKeyHint 

func (e *TagInputRadio) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputRadio)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputRadio) Form 

func (e *TagInputRadio) Form(form string) (ref *TagInputRadio)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputRadio) GetX 

func (e *TagInputRadio) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputRadio) GetXY 

func (e *TagInputRadio) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputRadio) GetY 

func (e *TagInputRadio) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputRadio) Hidden 

func (e *TagInputRadio) Hidden() (ref *TagInputRadio)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputRadio) Id 

func (e *TagInputRadio) Id(id string) (ref *TagInputRadio)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputRadio) InputMode 

func (e *TagInputRadio) InputMode(inputMode InputMode) (ref *TagInputRadio)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputRadio) Is 

func (e *TagInputRadio) Is(is string) (ref *TagInputRadio)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputRadio) ItemDrop 

func (e *TagInputRadio) ItemDrop(itemprop string) (ref *TagInputRadio)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputRadio) ItemId 

func (e *TagInputRadio) ItemId(id string) (ref *TagInputRadio)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputRadio) ItemRef 

func (e *TagInputRadio) ItemRef(itemref string) (ref *TagInputRadio)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputRadio) ItemType 

func (e *TagInputRadio) ItemType(itemType string) (ref *TagInputRadio)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputRadio) Lang 

func (e *TagInputRadio) Lang(language Language) (ref *TagInputRadio)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputRadio) List 

func (e *TagInputRadio) List(list string) (ref *TagInputRadio)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputRadio) Name 

func (e *TagInputRadio) Name(name string) (ref *TagInputRadio)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputRadio) Nonce 

func (e *TagInputRadio) Nonce(part ...string) (ref *TagInputRadio)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputRadio) ReadOnly 

func (e *TagInputRadio) ReadOnly(readonly bool) (ref *TagInputRadio)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputRadio) Required 

func (e *TagInputRadio) Required(required bool) (ref *TagInputRadio)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputRadio) SetX 

func (e *TagInputRadio) SetX(x int) (ref *TagInputRadio)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputRadio) SetXY 

func (e *TagInputRadio) SetXY(x, y int) (ref *TagInputRadio)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputRadio) SetY 

func (e *TagInputRadio) SetY(y int) (ref *TagInputRadio)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputRadio) Slot 

func (e *TagInputRadio) Slot(slot string) (ref *TagInputRadio)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputRadio) Spellcheck 

func (e *TagInputRadio) Spellcheck(spell bool) (ref *TagInputRadio)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputRadio) Style 

func (e *TagInputRadio) Style(style string) (ref *TagInputRadio)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRadio) TabIndex 

func (e *TagInputRadio) TabIndex(index int) (ref *TagInputRadio)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRadio) Title 

func (e *TagInputRadio) Title(title string) (ref *TagInputRadio)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRadio) Translate 

func (e *TagInputRadio) Translate(translate Translate) (ref *TagInputRadio)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputRadio) Type 

func (e *TagInputRadio) Type(inputType InputType) (ref *TagInputRadio)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputRadio) Value 

func (e *TagInputRadio) Value(value string) (ref *TagInputRadio)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputRange 

type TagInputRange struct {
	// contains filtered or unexported fields
}

func (*TagInputRange) AccessKey 

func (e *TagInputRange) AccessKey(key string) (ref *TagInputRange)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputRange) Append 

func (e *TagInputRange) Append(append interface{}) (ref *TagInputRange)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRange) AppendById 

func (e *TagInputRange) AppendById(appendId string) (ref *TagInputRange)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputRange) Autocomplete 

func (e *TagInputRange) Autocomplete(autocomplete Autocomplete) (ref *TagInputRange)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputRange) Autofocus 

func (e *TagInputRange) Autofocus(autofocus bool) (ref *TagInputRange)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputRange) Class 

func (e *TagInputRange) Class(class ...string) (ref *TagInputRange)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputRange) ContentEditable 

func (e *TagInputRange) ContentEditable(editable bool) (ref *TagInputRange)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputRange) CreateElement 

func (e *TagInputRange) CreateElement(tag Tag) (ref *TagInputRange)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputRange) Data 

func (e *TagInputRange) Data(data map[string]string) (ref *TagInputRange)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputRange) Dir 

func (e *TagInputRange) Dir(dir Dir) (ref *TagInputRange)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputRange) Disabled 

func (e *TagInputRange) Disabled(disabled bool) (ref *TagInputRange)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputRange) Draggable 

func (e *TagInputRange) Draggable(draggable Draggable) (ref *TagInputRange)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputRange) EnterKeyHint 

func (e *TagInputRange) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputRange)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputRange) Form 

func (e *TagInputRange) Form(form string) (ref *TagInputRange)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputRange) GetX 

func (e *TagInputRange) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputRange) GetXY 

func (e *TagInputRange) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputRange) GetY 

func (e *TagInputRange) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputRange) Hidden 

func (e *TagInputRange) Hidden() (ref *TagInputRange)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputRange) Id 

func (e *TagInputRange) Id(id string) (ref *TagInputRange)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputRange) InputMode 

func (e *TagInputRange) InputMode(inputMode InputMode) (ref *TagInputRange)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputRange) Is 

func (e *TagInputRange) Is(is string) (ref *TagInputRange)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputRange) ItemDrop 

func (e *TagInputRange) ItemDrop(itemprop string) (ref *TagInputRange)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputRange) ItemId 

func (e *TagInputRange) ItemId(id string) (ref *TagInputRange)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputRange) ItemRef 

func (e *TagInputRange) ItemRef(itemref string) (ref *TagInputRange)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputRange) ItemType 

func (e *TagInputRange) ItemType(itemType string) (ref *TagInputRange)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputRange) Lang 

func (e *TagInputRange) Lang(language Language) (ref *TagInputRange)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputRange) List 

func (e *TagInputRange) List(list string) (ref *TagInputRange)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputRange) Max 

func (e *TagInputRange) Max(max int) (ref *TagInputRange)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputRange) Min 

func (e *TagInputRange) Min(min int) (ref *TagInputRange)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputRange) Name 

func (e *TagInputRange) Name(name string) (ref *TagInputRange)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputRange) Nonce 

func (e *TagInputRange) Nonce(part ...string) (ref *TagInputRange)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputRange) ReadOnly 

func (e *TagInputRange) ReadOnly(readonly bool) (ref *TagInputRange)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputRange) Required 

func (e *TagInputRange) Required(required bool) (ref *TagInputRange)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputRange) SetX 

func (e *TagInputRange) SetX(x int) (ref *TagInputRange)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputRange) SetXY 

func (e *TagInputRange) SetXY(x, y int) (ref *TagInputRange)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputRange) SetY 

func (e *TagInputRange) SetY(y int) (ref *TagInputRange)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputRange) Slot 

func (e *TagInputRange) Slot(slot string) (ref *TagInputRange)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputRange) Spellcheck 

func (e *TagInputRange) Spellcheck(spell bool) (ref *TagInputRange)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputRange) Step 

func (e *TagInputRange) Step(step int) (ref *TagInputRange)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputRange) Style 

func (e *TagInputRange) Style(style string) (ref *TagInputRange)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRange) TabIndex 

func (e *TagInputRange) TabIndex(index int) (ref *TagInputRange)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRange) Title 

func (e *TagInputRange) Title(title string) (ref *TagInputRange)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputRange) Translate 

func (e *TagInputRange) Translate(translate Translate) (ref *TagInputRange)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputRange) Type 

func (e *TagInputRange) Type(inputType InputType) (ref *TagInputRange)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputRange) Value 

func (e *TagInputRange) Value(value string) (ref *TagInputRange)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputSearch 

type TagInputSearch struct {
	// contains filtered or unexported fields
}

func (*TagInputSearch) AccessKey 

func (e *TagInputSearch) AccessKey(key string) (ref *TagInputSearch)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputSearch) Append 

func (e *TagInputSearch) Append(append interface{}) (ref *TagInputSearch)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSearch) AppendById 

func (e *TagInputSearch) AppendById(appendId string) (ref *TagInputSearch)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSearch) Autocomplete 

func (e *TagInputSearch) Autocomplete(autocomplete Autocomplete) (ref *TagInputSearch)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputSearch) Autofocus 

func (e *TagInputSearch) Autofocus(autofocus bool) (ref *TagInputSearch)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputSearch) Class 

func (e *TagInputSearch) Class(class ...string) (ref *TagInputSearch)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputSearch) ContentEditable 

func (e *TagInputSearch) ContentEditable(editable bool) (ref *TagInputSearch)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputSearch) CreateElement 

func (e *TagInputSearch) CreateElement(tag Tag) (ref *TagInputSearch)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputSearch) Data 

func (e *TagInputSearch) Data(data map[string]string) (ref *TagInputSearch)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputSearch) Dir 

func (e *TagInputSearch) Dir(dir Dir) (ref *TagInputSearch)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputSearch) DirName 

func (e *TagInputSearch) DirName(dirname string) (ref *TagInputSearch)

DirName

English: 

Valid for text and search input types only, the dirname attribute enables the submission of the
directionality of the element. When included, the form control will submit with two name/value
pairs: the first being the name and value, the second being the value of the dirname as the name
with the value of ltr or rtl being set by the browser.

Português: 

Válido apenas para tipos de entrada de texto e pesquisa, o atributo dirname permite o envio da
direcionalidade do elemento. Quando incluído, o controle de formulário será enviado com dois pares
nomevalor: o primeiro sendo o nome e o valor, o segundo sendo o valor do dirname como o nome com o
valor de ltr ou rtl sendo definido pelo navegador.

func (*TagInputSearch) Disabled 

func (e *TagInputSearch) Disabled(disabled bool) (ref *TagInputSearch)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputSearch) Draggable 

func (e *TagInputSearch) Draggable(draggable Draggable) (ref *TagInputSearch)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputSearch) EnterKeyHint 

func (e *TagInputSearch) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputSearch)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputSearch) Form 

func (e *TagInputSearch) Form(form string) (ref *TagInputSearch)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputSearch) GetX 

func (e *TagInputSearch) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputSearch) GetXY 

func (e *TagInputSearch) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputSearch) GetY 

func (e *TagInputSearch) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputSearch) Hidden 

func (e *TagInputSearch) Hidden() (ref *TagInputSearch)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputSearch) Id 

func (e *TagInputSearch) Id(id string) (ref *TagInputSearch)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputSearch) InputMode 

func (e *TagInputSearch) InputMode(inputMode InputMode) (ref *TagInputSearch)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputSearch) Is 

func (e *TagInputSearch) Is(is string) (ref *TagInputSearch)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputSearch) ItemDrop 

func (e *TagInputSearch) ItemDrop(itemprop string) (ref *TagInputSearch)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputSearch) ItemId 

func (e *TagInputSearch) ItemId(id string) (ref *TagInputSearch)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputSearch) ItemRef 

func (e *TagInputSearch) ItemRef(itemref string) (ref *TagInputSearch)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputSearch) ItemType 

func (e *TagInputSearch) ItemType(itemType string) (ref *TagInputSearch)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputSearch) Lang 

func (e *TagInputSearch) Lang(language Language) (ref *TagInputSearch)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputSearch) List 

func (e *TagInputSearch) List(list string) (ref *TagInputSearch)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputSearch) MaxLength 

func (e *TagInputSearch) MaxLength(maxlength int) (ref *TagInputSearch)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputSearch) MinLength 

func (e *TagInputSearch) MinLength(minlength int) (ref *TagInputSearch)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputSearch) Name 

func (e *TagInputSearch) Name(name string) (ref *TagInputSearch)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputSearch) Nonce 

func (e *TagInputSearch) Nonce(part ...string) (ref *TagInputSearch)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputSearch) Placeholder 

func (e *TagInputSearch) Placeholder(placeholder string) (ref *TagInputSearch)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputSearch) ReadOnly 

func (e *TagInputSearch) ReadOnly(readonly bool) (ref *TagInputSearch)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputSearch) Required 

func (e *TagInputSearch) Required(required bool) (ref *TagInputSearch)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputSearch) SetX 

func (e *TagInputSearch) SetX(x int) (ref *TagInputSearch)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputSearch) SetXY 

func (e *TagInputSearch) SetXY(x, y int) (ref *TagInputSearch)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputSearch) SetY 

func (e *TagInputSearch) SetY(y int) (ref *TagInputSearch)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputSearch) Slot 

func (e *TagInputSearch) Slot(slot string) (ref *TagInputSearch)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputSearch) Spellcheck 

func (e *TagInputSearch) Spellcheck(spell bool) (ref *TagInputSearch)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputSearch) Style 

func (e *TagInputSearch) Style(style string) (ref *TagInputSearch)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSearch) TabIndex 

func (e *TagInputSearch) TabIndex(index int) (ref *TagInputSearch)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSearch) Title 

func (e *TagInputSearch) Title(title string) (ref *TagInputSearch)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSearch) Translate 

func (e *TagInputSearch) Translate(translate Translate) (ref *TagInputSearch)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputSearch) Type 

func (e *TagInputSearch) Type(inputType InputType) (ref *TagInputSearch)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputSearch) Value 

func (e *TagInputSearch) Value(value string) (ref *TagInputSearch)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputSubmit 

type TagInputSubmit struct {
	// contains filtered or unexported fields
}

func (*TagInputSubmit) AccessKey 

func (e *TagInputSubmit) AccessKey(key string) (ref *TagInputSubmit)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputSubmit) Append 

func (e *TagInputSubmit) Append(append interface{}) (ref *TagInputSubmit)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSubmit) AppendById 

func (e *TagInputSubmit) AppendById(appendId string) (ref *TagInputSubmit)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputSubmit) Autocomplete 

func (e *TagInputSubmit) Autocomplete(autocomplete Autocomplete) (ref *TagInputSubmit)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputSubmit) Autofocus 

func (e *TagInputSubmit) Autofocus(autofocus bool) (ref *TagInputSubmit)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputSubmit) Class 

func (e *TagInputSubmit) Class(class ...string) (ref *TagInputSubmit)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputSubmit) ContentEditable 

func (e *TagInputSubmit) ContentEditable(editable bool) (ref *TagInputSubmit)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputSubmit) CreateElement 

func (e *TagInputSubmit) CreateElement(tag Tag) (ref *TagInputSubmit)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputSubmit) Data 

func (e *TagInputSubmit) Data(data map[string]string) (ref *TagInputSubmit)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputSubmit) Dir 

func (e *TagInputSubmit) Dir(dir Dir) (ref *TagInputSubmit)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputSubmit) Disabled 

func (e *TagInputSubmit) Disabled(disabled bool) (ref *TagInputSubmit)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputSubmit) Draggable 

func (e *TagInputSubmit) Draggable(draggable Draggable) (ref *TagInputSubmit)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputSubmit) EnterKeyHint 

func (e *TagInputSubmit) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputSubmit)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputSubmit) Form 

func (e *TagInputSubmit) Form(form string) (ref *TagInputSubmit)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputSubmit) FormAction 

func (e *TagInputSubmit) FormAction(action string) (ref *TagInputSubmit)

FormAction

English: 

A string indicating the URL to which to submit the data. This takes precedence over the action
attribute on the <form> element that owns the <input>.

This attribute is also available on <input type="image"> and <button> elements.

Português: 

Uma string indicando o URL para o qual enviar os dados. Isso tem precedência sobre o atributo
action no elemento <form> que possui o <input>.

Este atributo também está disponível nos elementos <input type="image"> e <button>.

func (*TagInputSubmit) FormEncType 

func (e *TagInputSubmit) FormEncType(formenctype FormEncType) (ref *TagInputSubmit)

FormEncType

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), specifies how to encode the form data that is submitted. Possible values:

 Input:
   formenctype: specifies how to encode the form data

     application/x-www-form-urlencoded: The default if the attribute is not used.
     multipart/form-data: Use to submit <input> elements with their type attributes set to file.
     text/plain: Specified as a debugging aid; shouldn't be used for real form submission.

 Note:
   * If this attribute is specified, it overrides the enctype attribute of the button's form
     owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
especifica como codificar os dados do formulário que são enviados. Valores possíveis:

 Entrada:
   formenctype: especifica como codificar os dados do formulário

     KFormEncTypeApplication: O padrão se o atributo não for usado.
     KFormEncTypeMultiPart: Use para enviar elementos <input> com seus atributos de tipo definidos
       para arquivo.
     KFormEncTypeText: Especificado como auxiliar de depuração; não deve ser usado para envio de
       formulário real.

 Note:
   * Se este atributo for especificado, ele substituirá o atributo enctype do proprietário do
     formulário do botão.

func (*TagInputSubmit) FormMethod 

func (e *TagInputSubmit) FormMethod(method FormMethod) (ref *TagInputSubmit)

FormMethod

English: 

If the button is a submit button (it's inside/associated with a <form> and doesn't have
type="button"), this attribute specifies the HTTP method used to submit the form.

 Input:
   method: specifies the HTTP method used to submit
     KFormMethodPost: The data from the form are included in the body of the HTTP request when
       sent to the server. Use when the form contains information that shouldn't be public, like
       login credentials.
     KFormMethodGet: The form data are appended to the form's action URL, with a ? as a separator,
       and the resulting URL is sent to the server. Use this method when the form has no side
       effects, like search forms.

 Note:
   * If specified, this attribute overrides the method attribute of the button's form owner.

Português: 

Se o botão for um botão de envio (está associado a um <form> e não possui type="button"),
este atributo especifica o método HTTP usado para enviar o formulário.

 Input:
   method: especifica o método HTTP usado para enviar
     KFormMethodPost: Os dados do formulário são incluídos no corpo da solicitação HTTP quando
       enviados ao servidor. Use quando o formulário contém informações que não devem ser
       públicas, como credenciais de login.
     KFormMethodGet: Os dados do formulário são anexados à URL de ação do formulário, com um ?
       como separador e a URL resultante é enviada ao servidor. Use este método quando o
       formulário não tiver efeitos colaterais, como formulários de pesquisa.

 Nota:
   * Se especificado, este atributo substitui o atributo method do proprietário do formulário do
     botão.

func (*TagInputSubmit) FormTarget 

func (e *TagInputSubmit) FormTarget(formtarget Target) (ref *TagInputSubmit)

FormTarget

English: 

If the button is a submit button, this attribute is an author-defined name or standardized,
underscore-prefixed keyword indicating where to display the response from submitting the form.

This is the name of, or keyword for, a browsing context (a tab, window, or <iframe>). If this attribute is specified, it overrides the target attribute of the button's form owner. The following keywords have special meanings: 

KTargetSelf: the current browsing context; (Default)
KTargetBlank: usually a new tab, but users can configure browsers to open a new window instead;
KTargetParent: the parent browsing context of the current one. If no parent, behaves as _self;
KTargetTop: the topmost browsing context (the "highest" context that's an ancestor of the current
  one). If no ancestors, behaves as _self.

Português: 

Se o botão for um botão de envio, esse atributo será um nome definido pelo autor ou uma
palavra-chave padronizada com prefixo de sublinhado indicando onde exibir a resposta do envio do
formulário.

Este é o nome ou a palavra-chave de um contexto de navegação (uma guia, janela ou <iframe>). Se este atributo for especificado, ele substituirá o atributo de destino do proprietário do formulário do botão. As seguintes palavras-chave têm significados especiais: 

KTargetSelf: o contexto de navegação atual; (padrão)
KTargetBlank: geralmente uma nova guia, mas os usuários podem configurar os navegadores para
  abrir uma nova janela;
KTargetParent: o contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
KTargetTop: o contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do
  atual). Se não houver ancestrais, se comporta como _self.

func (*TagInputSubmit) FormValidate 

func (e *TagInputSubmit) FormValidate(validate bool) (ref *TagInputSubmit)

FormValidate

English: 

If the button is a submit button, 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.

Português: 

Se o botão for um botão de envio, este atributo booleano especifica que o formulário não deve ser
validado quando for enviado.

Se este atributo for especificado, ele substituirá o atributo novalidate do proprietário do formulário do botão.

func (*TagInputSubmit) GetX 

func (e *TagInputSubmit) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputSubmit) GetXY 

func (e *TagInputSubmit) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputSubmit) GetY 

func (e *TagInputSubmit) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputSubmit) Hidden 

func (e *TagInputSubmit) Hidden() (ref *TagInputSubmit)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputSubmit) Id 

func (e *TagInputSubmit) Id(id string) (ref *TagInputSubmit)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputSubmit) InputMode 

func (e *TagInputSubmit) InputMode(inputMode InputMode) (ref *TagInputSubmit)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputSubmit) Is 

func (e *TagInputSubmit) Is(is string) (ref *TagInputSubmit)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputSubmit) ItemDrop 

func (e *TagInputSubmit) ItemDrop(itemprop string) (ref *TagInputSubmit)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputSubmit) ItemId 

func (e *TagInputSubmit) ItemId(id string) (ref *TagInputSubmit)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputSubmit) ItemRef 

func (e *TagInputSubmit) ItemRef(itemref string) (ref *TagInputSubmit)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputSubmit) ItemType 

func (e *TagInputSubmit) ItemType(itemType string) (ref *TagInputSubmit)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputSubmit) Lang 

func (e *TagInputSubmit) Lang(language Language) (ref *TagInputSubmit)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputSubmit) List 

func (e *TagInputSubmit) List(list string) (ref *TagInputSubmit)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputSubmit) Name 

func (e *TagInputSubmit) Name(name string) (ref *TagInputSubmit)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputSubmit) Nonce 

func (e *TagInputSubmit) Nonce(part ...string) (ref *TagInputSubmit)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputSubmit) ReadOnly 

func (e *TagInputSubmit) ReadOnly(readonly bool) (ref *TagInputSubmit)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputSubmit) Required 

func (e *TagInputSubmit) Required(required bool) (ref *TagInputSubmit)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputSubmit) SetX 

func (e *TagInputSubmit) SetX(x int) (ref *TagInputSubmit)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputSubmit) SetXY 

func (e *TagInputSubmit) SetXY(x, y int) (ref *TagInputSubmit)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputSubmit) SetY 

func (e *TagInputSubmit) SetY(y int) (ref *TagInputSubmit)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputSubmit) Slot 

func (e *TagInputSubmit) Slot(slot string) (ref *TagInputSubmit)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputSubmit) Spellcheck 

func (e *TagInputSubmit) Spellcheck(spell bool) (ref *TagInputSubmit)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputSubmit) Style 

func (e *TagInputSubmit) Style(style string) (ref *TagInputSubmit)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSubmit) TabIndex 

func (e *TagInputSubmit) TabIndex(index int) (ref *TagInputSubmit)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSubmit) Title 

func (e *TagInputSubmit) Title(title string) (ref *TagInputSubmit)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputSubmit) Translate 

func (e *TagInputSubmit) Translate(translate Translate) (ref *TagInputSubmit)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputSubmit) Type 

func (e *TagInputSubmit) Type(inputType InputType) (ref *TagInputSubmit)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputSubmit) Value 

func (e *TagInputSubmit) Value(value string) (ref *TagInputSubmit)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputTel 

type TagInputTel struct {
	// contains filtered or unexported fields
}

func (*TagInputTel) AccessKey 

func (e *TagInputTel) AccessKey(key string) (ref *TagInputTel)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputTel) Append 

func (e *TagInputTel) Append(append interface{}) (ref *TagInputTel)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTel) AppendById 

func (e *TagInputTel) AppendById(appendId string) (ref *TagInputTel)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTel) Autocomplete 

func (e *TagInputTel) Autocomplete(autocomplete Autocomplete) (ref *TagInputTel)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputTel) Autofocus 

func (e *TagInputTel) Autofocus(autofocus bool) (ref *TagInputTel)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputTel) Class 

func (e *TagInputTel) Class(class ...string) (ref *TagInputTel)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputTel) ContentEditable 

func (e *TagInputTel) ContentEditable(editable bool) (ref *TagInputTel)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputTel) CreateElement 

func (e *TagInputTel) CreateElement(tag Tag) (ref *TagInputTel)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputTel) Data 

func (e *TagInputTel) Data(data map[string]string) (ref *TagInputTel)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputTel) Dir 

func (e *TagInputTel) Dir(dir Dir) (ref *TagInputTel)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputTel) Disabled 

func (e *TagInputTel) Disabled(disabled bool) (ref *TagInputTel)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputTel) Draggable 

func (e *TagInputTel) Draggable(draggable Draggable) (ref *TagInputTel)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputTel) EnterKeyHint 

func (e *TagInputTel) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputTel)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputTel) Form 

func (e *TagInputTel) Form(form string) (ref *TagInputTel)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputTel) GetX 

func (e *TagInputTel) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputTel) GetXY 

func (e *TagInputTel) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputTel) GetY 

func (e *TagInputTel) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputTel) Hidden 

func (e *TagInputTel) Hidden() (ref *TagInputTel)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputTel) Id 

func (e *TagInputTel) Id(id string) (ref *TagInputTel)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputTel) InputMode 

func (e *TagInputTel) InputMode(inputMode InputMode) (ref *TagInputTel)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputTel) Is 

func (e *TagInputTel) Is(is string) (ref *TagInputTel)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputTel) ItemDrop 

func (e *TagInputTel) ItemDrop(itemprop string) (ref *TagInputTel)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputTel) ItemId 

func (e *TagInputTel) ItemId(id string) (ref *TagInputTel)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputTel) ItemRef 

func (e *TagInputTel) ItemRef(itemref string) (ref *TagInputTel)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputTel) ItemType 

func (e *TagInputTel) ItemType(itemType string) (ref *TagInputTel)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputTel) Lang 

func (e *TagInputTel) Lang(language Language) (ref *TagInputTel)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputTel) List 

func (e *TagInputTel) List(list string) (ref *TagInputTel)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputTel) Max 

func (e *TagInputTel) Max(max int) (ref *TagInputTel)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTel) MaxLength 

func (e *TagInputTel) MaxLength(maxlength int) (ref *TagInputTel)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputTel) Min 

func (e *TagInputTel) Min(min int) (ref *TagInputTel)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTel) MinLength 

func (e *TagInputTel) MinLength(minlength int) (ref *TagInputTel)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputTel) Name 

func (e *TagInputTel) Name(name string) (ref *TagInputTel)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputTel) Nonce 

func (e *TagInputTel) Nonce(part ...string) (ref *TagInputTel)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputTel) Pattern 

func (e *TagInputTel) Pattern(pattern string) (ref *TagInputTel)

Pattern

English: 

The pattern attribute, when specified, is a regular expression that the input's value must match
in order for the value to pass constraint validation. It must be a valid JavaScript regular
expression, as used by the RegExp type, and as documented in our guide on regular expressions;
the 'u' flag is specified when compiling the regular expression, so that the pattern is treated
as a sequence of Unicode code points, instead of as ASCII. No forward slashes should be specified
around the pattern text.

If the pattern attribute is present but is not specified or is invalid, no regular expression is applied and this attribute is ignored completely. If the pattern attribute is valid and a non-empty value does not match the pattern, constraint validation will prevent form submission. 

Note:
  * If using the pattern attribute, inform the user about the expected format by including
    explanatory text nearby. You can also include a title attribute to explain what the
    requirements are to match the pattern; most browsers will display this title as a tooltip.
    The visible explanation is required for accessibility. The tooltip is an enhancement.

Português: 

O atributo pattern, quando especificado, é uma expressão regular que o valor da entrada deve
corresponder para que o valor passe na validação de restrição. Deve ser uma expressão regular
JavaScript válida, conforme usada pelo tipo RegExp e conforme documentado em nosso guia sobre
expressões regulares; o sinalizador 'u' é especificado ao compilar a expressão regular, para que
o padrão seja tratado como uma sequência de pontos de código Unicode, em vez de como ASCII.
Nenhuma barra deve ser especificada ao redor do texto do padrão.

Se o atributo pattern estiver presente, mas não for especificado ou for inválido, nenhuma expressão regular será aplicada e esse atributo será completamente ignorado. Se o atributo de padrão for válido e um valor não vazio não corresponder ao padrão, a validação de restrição impedirá o envio do formulário. 

Nota:
  * Se estiver usando o atributo pattern, informe o usuário sobre o formato esperado incluindo
    um texto explicativo próximo. Você também pode incluir um atributo title para explicar quais
    são os requisitos para corresponder ao padrão; a maioria dos navegadores exibirá este título
    como uma dica de ferramenta. A explicação visível é necessária para acessibilidade. A dica
    de ferramenta é um aprimoramento.

func (*TagInputTel) Placeholder 

func (e *TagInputTel) Placeholder(placeholder string) (ref *TagInputTel)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputTel) ReadOnly 

func (e *TagInputTel) ReadOnly(readonly bool) (ref *TagInputTel)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputTel) Required 

func (e *TagInputTel) Required(required bool) (ref *TagInputTel)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputTel) SetX 

func (e *TagInputTel) SetX(x int) (ref *TagInputTel)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputTel) SetXY 

func (e *TagInputTel) SetXY(x, y int) (ref *TagInputTel)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputTel) SetY 

func (e *TagInputTel) SetY(y int) (ref *TagInputTel)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputTel) Size 

func (e *TagInputTel) Size(size int) (ref *TagInputTel)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputTel) Slot 

func (e *TagInputTel) Slot(slot string) (ref *TagInputTel)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputTel) Spellcheck 

func (e *TagInputTel) Spellcheck(spell bool) (ref *TagInputTel)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputTel) Step 

func (e *TagInputTel) Step(step int) (ref *TagInputTel)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputTel) Style 

func (e *TagInputTel) Style(style string) (ref *TagInputTel)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTel) TabIndex 

func (e *TagInputTel) TabIndex(index int) (ref *TagInputTel)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTel) Title 

func (e *TagInputTel) Title(title string) (ref *TagInputTel)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTel) Translate 

func (e *TagInputTel) Translate(translate Translate) (ref *TagInputTel)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputTel) Type 

func (e *TagInputTel) Type(inputType InputType) (ref *TagInputTel)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputTel) Value 

func (e *TagInputTel) Value(value string) (ref *TagInputTel)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputText 

type TagInputText struct {
	// contains filtered or unexported fields
}

func (*TagInputText) AccessKey 

func (e *TagInputText) AccessKey(key string) (ref *TagInputText)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputText) Append 

func (e *TagInputText) Append(append interface{}) (ref *TagInputText)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputText) AppendById 

func (e *TagInputText) AppendById(appendId string) (ref *TagInputText)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputText) Autocomplete 

func (e *TagInputText) Autocomplete(autocomplete Autocomplete) (ref *TagInputText)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputText) Autofocus 

func (e *TagInputText) Autofocus(autofocus bool) (ref *TagInputText)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputText) Class 

func (e *TagInputText) Class(class ...string) (ref *TagInputText)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputText) ContentEditable 

func (e *TagInputText) ContentEditable(editable bool) (ref *TagInputText)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputText) CreateElement 

func (e *TagInputText) CreateElement(tag Tag) (ref *TagInputText)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputText) Data 

func (e *TagInputText) Data(data map[string]string) (ref *TagInputText)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputText) Dir 

func (e *TagInputText) Dir(dir Dir) (ref *TagInputText)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputText) DirName 

func (e *TagInputText) DirName(dirname string) (ref *TagInputText)

DirName

English: 

Valid for text and search input types only, the dirname attribute enables the submission of the
directionality of the element. When included, the form control will submit with two name/value
pairs: the first being the name and value, the second being the value of the dirname as the name
with the value of ltr or rtl being set by the browser.

Português: 

Válido apenas para tipos de entrada de texto e pesquisa, o atributo dirname permite o envio da
direcionalidade do elemento. Quando incluído, o controle de formulário será enviado com dois pares
nomevalor: o primeiro sendo o nome e o valor, o segundo sendo o valor do dirname como o nome com o
valor de ltr ou rtl sendo definido pelo navegador.

func (*TagInputText) Disabled 

func (e *TagInputText) Disabled(disabled bool) (ref *TagInputText)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputText) Draggable 

func (e *TagInputText) Draggable(draggable Draggable) (ref *TagInputText)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputText) EnterKeyHint 

func (e *TagInputText) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputText)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputText) Form 

func (e *TagInputText) Form(form string) (ref *TagInputText)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputText) GetX 

func (e *TagInputText) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputText) GetXY 

func (e *TagInputText) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputText) GetY 

func (e *TagInputText) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputText) Hidden 

func (e *TagInputText) Hidden() (ref *TagInputText)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputText) Id 

func (e *TagInputText) Id(id string) (ref *TagInputText)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputText) InputMode 

func (e *TagInputText) InputMode(inputMode InputMode) (ref *TagInputText)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputText) Is 

func (e *TagInputText) Is(is string) (ref *TagInputText)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputText) ItemDrop 

func (e *TagInputText) ItemDrop(itemprop string) (ref *TagInputText)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputText) ItemId 

func (e *TagInputText) ItemId(id string) (ref *TagInputText)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputText) ItemRef 

func (e *TagInputText) ItemRef(itemref string) (ref *TagInputText)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputText) ItemType 

func (e *TagInputText) ItemType(itemType string) (ref *TagInputText)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputText) Lang 

func (e *TagInputText) Lang(language Language) (ref *TagInputText)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputText) List 

func (e *TagInputText) List(list string) (ref *TagInputText)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputText) MaxLength 

func (e *TagInputText) MaxLength(maxlength int) (ref *TagInputText)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputText) MinLength 

func (e *TagInputText) MinLength(minlength int) (ref *TagInputText)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputText) Name 

func (e *TagInputText) Name(name string) (ref *TagInputText)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputText) Nonce 

func (e *TagInputText) Nonce(part ...string) (ref *TagInputText)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputText) Pattern 

func (e *TagInputText) Pattern(pattern string) (ref *TagInputText)

Pattern

English: 

The pattern attribute, when specified, is a regular expression that the input's value must match
in order for the value to pass constraint validation. It must be a valid JavaScript regular
expression, as used by the RegExp type, and as documented in our guide on regular expressions;
the 'u' flag is specified when compiling the regular expression, so that the pattern is treated
as a sequence of Unicode code points, instead of as ASCII. No forward slashes should be specified
around the pattern text.

If the pattern attribute is present but is not specified or is invalid, no regular expression is applied and this attribute is ignored completely. If the pattern attribute is valid and a non-empty value does not match the pattern, constraint validation will prevent form submission. 

Note:
  * If using the pattern attribute, inform the user about the expected format by including
    explanatory text nearby. You can also include a title attribute to explain what the
    requirements are to match the pattern; most browsers will display this title as a tooltip.
    The visible explanation is required for accessibility. The tooltip is an enhancement.

Português: 

O atributo pattern, quando especificado, é uma expressão regular que o valor da entrada deve
corresponder para que o valor passe na validação de restrição. Deve ser uma expressão regular
JavaScript válida, conforme usada pelo tipo RegExp e conforme documentado em nosso guia sobre
expressões regulares; o sinalizador 'u' é especificado ao compilar a expressão regular, para que
o padrão seja tratado como uma sequência de pontos de código Unicode, em vez de como ASCII.
Nenhuma barra deve ser especificada ao redor do texto do padrão.

Se o atributo pattern estiver presente, mas não for especificado ou for inválido, nenhuma expressão regular será aplicada e esse atributo será completamente ignorado. Se o atributo de padrão for válido e um valor não vazio não corresponder ao padrão, a validação de restrição impedirá o envio do formulário. 

Nota:
  * Se estiver usando o atributo pattern, informe o usuário sobre o formato esperado incluindo
    um texto explicativo próximo. Você também pode incluir um atributo title para explicar quais
    são os requisitos para corresponder ao padrão; a maioria dos navegadores exibirá este título
    como uma dica de ferramenta. A explicação visível é necessária para acessibilidade. A dica
    de ferramenta é um aprimoramento.

func (*TagInputText) Placeholder 

func (e *TagInputText) Placeholder(placeholder string) (ref *TagInputText)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputText) ReadOnly 

func (e *TagInputText) ReadOnly(readonly bool) (ref *TagInputText)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputText) Required 

func (e *TagInputText) Required(required bool) (ref *TagInputText)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputText) SetX 

func (e *TagInputText) SetX(x int) (ref *TagInputText)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputText) SetXY 

func (e *TagInputText) SetXY(x, y int) (ref *TagInputText)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputText) SetY 

func (e *TagInputText) SetY(y int) (ref *TagInputText)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputText) Size 

func (e *TagInputText) Size(size int) (ref *TagInputText)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputText) Slot 

func (e *TagInputText) Slot(slot string) (ref *TagInputText)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputText) Spellcheck 

func (e *TagInputText) Spellcheck(spell bool) (ref *TagInputText)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputText) Style 

func (e *TagInputText) Style(style string) (ref *TagInputText)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputText) TabIndex 

func (e *TagInputText) TabIndex(index int) (ref *TagInputText)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputText) Title 

func (e *TagInputText) Title(title string) (ref *TagInputText)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputText) Translate 

func (e *TagInputText) Translate(translate Translate) (ref *TagInputText)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputText) Type 

func (e *TagInputText) Type(inputType InputType) (ref *TagInputText)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputText) Value 

func (e *TagInputText) Value(value string) (ref *TagInputText)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputTime 

type TagInputTime struct {
	// contains filtered or unexported fields
}

func (*TagInputTime) AccessKey 

func (e *TagInputTime) AccessKey(key string) (ref *TagInputTime)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputTime) Append 

func (e *TagInputTime) Append(append interface{}) (ref *TagInputTime)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTime) AppendById 

func (e *TagInputTime) AppendById(appendId string) (ref *TagInputTime)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputTime) Autocomplete 

func (e *TagInputTime) Autocomplete(autocomplete Autocomplete) (ref *TagInputTime)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputTime) Autofocus 

func (e *TagInputTime) Autofocus(autofocus bool) (ref *TagInputTime)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputTime) Class 

func (e *TagInputTime) Class(class ...string) (ref *TagInputTime)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputTime) ContentEditable 

func (e *TagInputTime) ContentEditable(editable bool) (ref *TagInputTime)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputTime) CreateElement 

func (e *TagInputTime) CreateElement(tag Tag) (ref *TagInputTime)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputTime) Data 

func (e *TagInputTime) Data(data map[string]string) (ref *TagInputTime)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputTime) Dir 

func (e *TagInputTime) Dir(dir Dir) (ref *TagInputTime)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputTime) Disabled 

func (e *TagInputTime) Disabled(disabled bool) (ref *TagInputTime)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputTime) Draggable 

func (e *TagInputTime) Draggable(draggable Draggable) (ref *TagInputTime)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputTime) EnterKeyHint 

func (e *TagInputTime) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputTime)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputTime) Form 

func (e *TagInputTime) Form(form string) (ref *TagInputTime)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputTime) GetX 

func (e *TagInputTime) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputTime) GetXY 

func (e *TagInputTime) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputTime) GetY 

func (e *TagInputTime) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputTime) Hidden 

func (e *TagInputTime) Hidden() (ref *TagInputTime)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputTime) Id 

func (e *TagInputTime) Id(id string) (ref *TagInputTime)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputTime) InputMode 

func (e *TagInputTime) InputMode(inputMode InputMode) (ref *TagInputTime)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputTime) Is 

func (e *TagInputTime) Is(is string) (ref *TagInputTime)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputTime) ItemDrop 

func (e *TagInputTime) ItemDrop(itemprop string) (ref *TagInputTime)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputTime) ItemId 

func (e *TagInputTime) ItemId(id string) (ref *TagInputTime)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputTime) ItemRef 

func (e *TagInputTime) ItemRef(itemref string) (ref *TagInputTime)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputTime) ItemType 

func (e *TagInputTime) ItemType(itemType string) (ref *TagInputTime)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputTime) Lang 

func (e *TagInputTime) Lang(language Language) (ref *TagInputTime)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputTime) List 

func (e *TagInputTime) List(list string) (ref *TagInputTime)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputTime) Max 

func (e *TagInputTime) Max(max int) (ref *TagInputTime)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTime) Min 

func (e *TagInputTime) Min(min int) (ref *TagInputTime)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputTime) Name 

func (e *TagInputTime) Name(name string) (ref *TagInputTime)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputTime) Nonce 

func (e *TagInputTime) Nonce(part ...string) (ref *TagInputTime)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputTime) ReadOnly 

func (e *TagInputTime) ReadOnly(readonly bool) (ref *TagInputTime)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputTime) Required 

func (e *TagInputTime) Required(required bool) (ref *TagInputTime)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputTime) SetX 

func (e *TagInputTime) SetX(x int) (ref *TagInputTime)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputTime) SetXY 

func (e *TagInputTime) SetXY(x, y int) (ref *TagInputTime)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputTime) SetY 

func (e *TagInputTime) SetY(y int) (ref *TagInputTime)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputTime) Slot 

func (e *TagInputTime) Slot(slot string) (ref *TagInputTime)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputTime) Spellcheck 

func (e *TagInputTime) Spellcheck(spell bool) (ref *TagInputTime)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputTime) Step 

func (e *TagInputTime) Step(step int) (ref *TagInputTime)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputTime) Style 

func (e *TagInputTime) Style(style string) (ref *TagInputTime)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTime) TabIndex 

func (e *TagInputTime) TabIndex(index int) (ref *TagInputTime)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTime) Title 

func (e *TagInputTime) Title(title string) (ref *TagInputTime)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputTime) Translate 

func (e *TagInputTime) Translate(translate Translate) (ref *TagInputTime)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputTime) Type 

func (e *TagInputTime) Type(inputType InputType) (ref *TagInputTime)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputTime) Value 

func (e *TagInputTime) Value(value string) (ref *TagInputTime)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputUrl 

type TagInputUrl struct {
	// contains filtered or unexported fields
}

func (*TagInputUrl) AccessKey 

func (e *TagInputUrl) AccessKey(key string) (ref *TagInputUrl)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputUrl) Append 

func (e *TagInputUrl) Append(append interface{}) (ref *TagInputUrl)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputUrl) AppendById 

func (e *TagInputUrl) AppendById(appendId string) (ref *TagInputUrl)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputUrl) Autocomplete 

func (e *TagInputUrl) Autocomplete(autocomplete Autocomplete) (ref *TagInputUrl)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputUrl) Autofocus 

func (e *TagInputUrl) Autofocus(autofocus bool) (ref *TagInputUrl)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputUrl) Class 

func (e *TagInputUrl) Class(class ...string) (ref *TagInputUrl)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputUrl) ContentEditable 

func (e *TagInputUrl) ContentEditable(editable bool) (ref *TagInputUrl)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputUrl) CreateElement 

func (e *TagInputUrl) CreateElement(tag Tag) (ref *TagInputUrl)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputUrl) Data 

func (e *TagInputUrl) Data(data map[string]string) (ref *TagInputUrl)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputUrl) Dir 

func (e *TagInputUrl) Dir(dir Dir) (ref *TagInputUrl)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputUrl) Disabled 

func (e *TagInputUrl) Disabled(disabled bool) (ref *TagInputUrl)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputUrl) Draggable 

func (e *TagInputUrl) Draggable(draggable Draggable) (ref *TagInputUrl)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputUrl) EnterKeyHint 

func (e *TagInputUrl) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputUrl)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputUrl) Form 

func (e *TagInputUrl) Form(form string) (ref *TagInputUrl)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputUrl) GetX 

func (e *TagInputUrl) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputUrl) GetXY 

func (e *TagInputUrl) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputUrl) GetY 

func (e *TagInputUrl) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputUrl) Hidden 

func (e *TagInputUrl) Hidden() (ref *TagInputUrl)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputUrl) Id 

func (e *TagInputUrl) Id(id string) (ref *TagInputUrl)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputUrl) InputMode 

func (e *TagInputUrl) InputMode(inputMode InputMode) (ref *TagInputUrl)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputUrl) Is 

func (e *TagInputUrl) Is(is string) (ref *TagInputUrl)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputUrl) ItemDrop 

func (e *TagInputUrl) ItemDrop(itemprop string) (ref *TagInputUrl)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputUrl) ItemId 

func (e *TagInputUrl) ItemId(id string) (ref *TagInputUrl)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputUrl) ItemRef 

func (e *TagInputUrl) ItemRef(itemref string) (ref *TagInputUrl)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputUrl) ItemType 

func (e *TagInputUrl) ItemType(itemType string) (ref *TagInputUrl)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputUrl) Lang 

func (e *TagInputUrl) Lang(language Language) (ref *TagInputUrl)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputUrl) List 

func (e *TagInputUrl) List(list string) (ref *TagInputUrl)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputUrl) MaxLength 

func (e *TagInputUrl) MaxLength(maxlength int) (ref *TagInputUrl)

MaxLength

English: 

Valid for text, search, url, tel, email, and password, it defines the maximum number of characters
(as UTF-16 code units) the user can enter into the field. This must be an integer value 0 or
higher. If no maxlength is specified, or an invalid value is specified, the field has no maximum
length. This value must also be greater than or equal to the value of minlength.

The input will fail constraint validation if the length of the text entered into the field is greater than maxlength UTF-16 code units long. By default, browsers prevent users from entering more characters than allowed by the maxlength attribute.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número máximo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo.

Este deve ser um valor inteiro 0 ou superior. Se nenhum comprimento máximo for especificado ou um valor inválido for especificado, o campo não terá comprimento máximo. Esse valor também deve ser maior ou igual ao valor de minlength.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for maior que o comprimento máximo das unidades de código UTF-16. Por padrão, os navegadores impedem que os usuários insiram mais caracteres do que o permitido pelo atributo maxlength.

func (*TagInputUrl) MinLength 

func (e *TagInputUrl) MinLength(minlength int) (ref *TagInputUrl)

MinLength

English: 

Valid for text, search, url, tel, email, and password, it defines the minimum number of
characters (as UTF-16 code units) the user can enter into the entry field.

This must be an non-negative integer value smaller than or equal to the value specified by maxlength. If no minlength is specified, or an invalid value is specified, the input has no minimum length.

The input will fail constraint validation if the length of the text entered into the field is fewer than minlength UTF-16 code units long, preventing form submission.

Português: 

Válido para texto, pesquisa, url, tel, email e senha, define o número mínimo de caracteres
(como unidades de código UTF-16) que o usuário pode inserir no campo de entrada.

Este deve ser um valor inteiro não negativo menor ou igual ao valor especificado por maxlength. Se nenhum comprimento mínimo for especificado ou um valor inválido for especificado, a entrada não terá comprimento mínimo.

A entrada falhará na validação de restrição se o comprimento do texto inserido no campo for inferior a unidades de código UTF-16 de comprimento mínimo, impedindo o envio do formulário.

func (*TagInputUrl) Name 

func (e *TagInputUrl) Name(name string) (ref *TagInputUrl)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputUrl) Nonce 

func (e *TagInputUrl) Nonce(part ...string) (ref *TagInputUrl)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputUrl) Placeholder 

func (e *TagInputUrl) Placeholder(placeholder string) (ref *TagInputUrl)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagInputUrl) ReadOnly 

func (e *TagInputUrl) ReadOnly(readonly bool) (ref *TagInputUrl)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputUrl) Required 

func (e *TagInputUrl) Required(required bool) (ref *TagInputUrl)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputUrl) SetX 

func (e *TagInputUrl) SetX(x int) (ref *TagInputUrl)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputUrl) SetXY 

func (e *TagInputUrl) SetXY(x, y int) (ref *TagInputUrl)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputUrl) SetY 

func (e *TagInputUrl) SetY(y int) (ref *TagInputUrl)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputUrl) Size 

func (e *TagInputUrl) Size(size int) (ref *TagInputUrl)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagInputUrl) Slot 

func (e *TagInputUrl) Slot(slot string) (ref *TagInputUrl)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputUrl) Spellcheck 

func (e *TagInputUrl) Spellcheck(spell bool) (ref *TagInputUrl)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputUrl) Style 

func (e *TagInputUrl) Style(style string) (ref *TagInputUrl)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputUrl) TabIndex 

func (e *TagInputUrl) TabIndex(index int) (ref *TagInputUrl)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputUrl) Title 

func (e *TagInputUrl) Title(title string) (ref *TagInputUrl)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputUrl) Translate 

func (e *TagInputUrl) Translate(translate Translate) (ref *TagInputUrl)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputUrl) Type 

func (e *TagInputUrl) Type(inputType InputType) (ref *TagInputUrl)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputUrl) Value 

func (e *TagInputUrl) Value(value string) (ref *TagInputUrl)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagInputWeek 

type TagInputWeek struct {
	// contains filtered or unexported fields
}

func (*TagInputWeek) AccessKey 

func (e *TagInputWeek) AccessKey(key string) (ref *TagInputWeek)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagInputWeek) Append 

func (e *TagInputWeek) Append(append interface{}) (ref *TagInputWeek)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputWeek) AppendById 

func (e *TagInputWeek) AppendById(appendId string) (ref *TagInputWeek)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagInputWeek) Autocomplete 

func (e *TagInputWeek) Autocomplete(autocomplete Autocomplete) (ref *TagInputWeek)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagInputWeek) Autofocus 

func (e *TagInputWeek) Autofocus(autofocus bool) (ref *TagInputWeek)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagInputWeek) Class 

func (e *TagInputWeek) Class(class ...string) (ref *TagInputWeek)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagInputWeek) ContentEditable 

func (e *TagInputWeek) ContentEditable(editable bool) (ref *TagInputWeek)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagInputWeek) CreateElement 

func (e *TagInputWeek) CreateElement(tag Tag) (ref *TagInputWeek)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagInputWeek) Data 

func (e *TagInputWeek) Data(data map[string]string) (ref *TagInputWeek)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagInputWeek) Dir 

func (e *TagInputWeek) Dir(dir Dir) (ref *TagInputWeek)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagInputWeek) Disabled 

func (e *TagInputWeek) Disabled(disabled bool) (ref *TagInputWeek)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagInputWeek) Draggable 

func (e *TagInputWeek) Draggable(draggable Draggable) (ref *TagInputWeek)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagInputWeek) EnterKeyHint 

func (e *TagInputWeek) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagInputWeek)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagInputWeek) Form 

func (e *TagInputWeek) Form(form string) (ref *TagInputWeek)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagInputWeek) GetX 

func (e *TagInputWeek) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagInputWeek) GetXY 

func (e *TagInputWeek) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagInputWeek) GetY 

func (e *TagInputWeek) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagInputWeek) Hidden 

func (e *TagInputWeek) Hidden() (ref *TagInputWeek)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagInputWeek) Id 

func (e *TagInputWeek) Id(id string) (ref *TagInputWeek)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagInputWeek) InputMode 

func (e *TagInputWeek) InputMode(inputMode InputMode) (ref *TagInputWeek)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagInputWeek) Is 

func (e *TagInputWeek) Is(is string) (ref *TagInputWeek)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagInputWeek) ItemDrop 

func (e *TagInputWeek) ItemDrop(itemprop string) (ref *TagInputWeek)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagInputWeek) ItemId 

func (e *TagInputWeek) ItemId(id string) (ref *TagInputWeek)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagInputWeek) ItemRef 

func (e *TagInputWeek) ItemRef(itemref string) (ref *TagInputWeek)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagInputWeek) ItemType 

func (e *TagInputWeek) ItemType(itemType string) (ref *TagInputWeek)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagInputWeek) Lang 

func (e *TagInputWeek) Lang(language Language) (ref *TagInputWeek)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagInputWeek) List 

func (e *TagInputWeek) List(list string) (ref *TagInputWeek)

List

English: 

The value given to the list attribute should be the id of a <datalist> element located in the same
document.

The <datalist> provides a list of predefined values to suggest to the user for this input. Any values in the list that are not compatible with the type are not included in the suggested options. The values provided are suggestions, not requirements: users can select from this predefined list or provide a different value.

It is valid on text, search, url, tel, email, date, month, week, time, datetime-local, number, range, and color.

Per the specifications, the list attribute is not supported by the hidden, password, checkbox, radio, file, or any of the button types.

Depending on the browser, the user may see a custom color palette suggested, tic marks along a range, or even a input that opens like a <select> but allows for non-listed values. Check out the browser compatibility table for the other input types.

See factoryBrowser.NewTagDataList()

Português: 

O valor dado ao atributo list deve ser o id de um elemento <datalist> localizado no mesmo
documento.

O <datalist> fornece uma lista de valores predefinidos para sugerir ao usuário para esta entrada. Quaisquer valores na lista que não sejam compatíveis com o tipo não são incluídos nas opções sugeridas. Os valores fornecidos são sugestões, não requisitos: os usuários podem selecionar dessa lista predefinida ou fornecer um valor diferente.

É válido em texto, pesquisa, url, telefone, email, data, mês, semana, hora, data e hora local, número, intervalo e cor.

De acordo com as especificações, o atributo de lista não é suportado pelo oculto, senha, caixa de seleção, rádio, arquivo ou qualquer um dos tipos de botão.

Dependendo do navegador, o usuário pode ver uma paleta de cores personalizada sugerida, marcas de tique ao longo de um intervalo ou até mesmo uma entrada que abre como um <select>, mas permite valores não listados. Confira a tabela de compatibilidade do navegador para os outros tipos de entrada.

Veja factoryBrowser.NewTagDataList()

func (*TagInputWeek) Max 

func (e *TagInputWeek) Max(max int) (ref *TagInputWeek)

Max

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the greatest
value in the range of permitted values.
If the value entered into the element exceeds this, the element fails constraint validation.
If the value of the max attribute isn't a number, then the element has no maximum value.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, datetime-local, número e intervalo, define o maior valor no
intervalo de valores permitidos. Se o valor inserido no elemento exceder isso, o elemento falhará
na validação de restrição. Se o valor do atributo max não for um número, o elemento não terá
valor máximo.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputWeek) Min 

func (e *TagInputWeek) Min(min int) (ref *TagInputWeek)

Min

English: 

Valid for date, month, week, time, datetime-local, number, and range, it defines the most negative
value in the range of permitted values.

If the value entered into the element is less than this, the element fails constraint validation. If the value of the min attribute isn't a number, then the element has no minimum value.

This value must be less than or equal to the value of the max attribute. If the min attribute is present but is not specified or is invalid, no min value is applied. If the min attribute is valid and a non-empty value is less than the minimum allowed by the min attribute, constraint validation will prevent form submission. See Client-side validation for more information.

There is a special case: if the data type is periodic (such as for dates or times), the value of max may be lower than the value of min, which indicates that the range may wrap around; for example, this allows you to specify a time range from 10 PM to 4 AM.

Português: 

Válido para data, mês, semana, hora, data e hora local, número e intervalo, define o valor mais
negativo no intervalo de valores permitidos.

Se o valor inserido no elemento for menor que isso, o elemento falhará na validação de restrição. Se o valor do atributo min não for um número, o elemento não terá valor mínimo.

Esse valor deve ser menor ou igual ao valor do atributo max. Se o atributo min estiver presente, mas não for especificado ou for inválido, nenhum valor min será aplicado. Se o atributo min for válido e um valor não vazio for menor que o mínimo permitido pelo atributo min, a validação de restrição impedirá o envio do formulário. Consulte Validação do lado do cliente para obter mais informações.

Há um caso especial: se o tipo de dado for periódico (como para datas ou horas), o valor de max pode ser menor que o valor de min, o que indica que o intervalo pode ser contornado; por exemplo, isso permite que você especifique um intervalo de tempo das 22h às 4h.

func (*TagInputWeek) Name 

func (e *TagInputWeek) Name(name string) (ref *TagInputWeek)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagInputWeek) Nonce 

func (e *TagInputWeek) Nonce(part ...string) (ref *TagInputWeek)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagInputWeek) ReadOnly 

func (e *TagInputWeek) ReadOnly(readonly bool) (ref *TagInputWeek)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

Português: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the value of the input. The readonly attribute is supported by the text, search, url, tel, email, date, month, week, time, datetime-local, number, and password input types.

func (*TagInputWeek) Required 

func (e *TagInputWeek) Required(required bool) (ref *TagInputWeek)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagInputWeek) SetX 

func (e *TagInputWeek) SetX(x int) (ref *TagInputWeek)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagInputWeek) SetXY 

func (e *TagInputWeek) SetXY(x, y int) (ref *TagInputWeek)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagInputWeek) SetY 

func (e *TagInputWeek) SetY(y int) (ref *TagInputWeek)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagInputWeek) Slot 

func (e *TagInputWeek) Slot(slot string) (ref *TagInputWeek)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagInputWeek) Spellcheck 

func (e *TagInputWeek) Spellcheck(spell bool) (ref *TagInputWeek)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagInputWeek) Step 

func (e *TagInputWeek) Step(step int) (ref *TagInputWeek)

Step

English: 

Valid for the numeric input types, including number, date/time input types, and range, the step
attribute is a number that specifies the granularity that the value must adhere to.

 If not explicitly included:
   * step defaults to 1 for number and range;
   * For the date/time input types, step is expressed in seconds, with the default step being 60
     seconds. The step scale factor is 1000 (which converts the seconds to milliseconds, as used
     in other algorithms);
   * The value must be a positive number—integer or float—or the special value any, which means
     no stepping is implied, and any value is allowed (barring other constraints, such as min and
     max).

If any is not explicitly set, valid values for the number, date/time input types, and range input types are equal to the basis for stepping — the min value and increments of the step value, up to the max value, if specified.

For example, if you have <input type="number" min="10" step="2">, then any even integer, 10 or greater, is valid. If omitted, <input type="number">, any integer is valid, but floats (like 4.2) are not valid, because step defaults to 1. For 4.2 to be valid, step would have had to be set to any, 0.1, 0.2, or any the min value would have had to be a number ending in .2, such as <input type="number" min="-5.2"> 

Note:
  * When the data entered by the user doesn't adhere to the stepping configuration, the value is
    considered invalid in constraint validation and will match the :invalid pseudoclass.

Português: 

Válido para os tipos de entrada numérica, incluindo número, tipos de entrada de data e hora e
intervalo, o atributo step é um número que especifica a granularidade à qual o valor deve aderir.

 Se não estiver explicitamente incluído:
   * step padroniza para 1 para número e intervalo.
   * Para os tipos de entrada de data e hora, a etapa é expressa em segundos, com a etapa padrão
     sendo 60 segundos. O fator de escala de passo é 1000 (que converte os segundos em
     milissegundos, conforme usado em outros algoritmos).
   * O valor deve ser um número positivo — inteiro ou flutuante — ou o valor especial any, o que
     significa que nenhuma depuração está implícita e qualquer valor é permitido (exceto outras
     restrições, como min e max).

Se algum não for definido explicitamente, os valores válidos para o número, tipos de entrada de data e hora e tipos de entrada de intervalo são iguais à base para a depuração — o valor mínimo e os incrementos do valor da etapa, até o valor máximo, se especificado.

Por exemplo, se você tiver <input type="number" min="10" step="2">, qualquer número inteiro par, 10 ou maior, é válido. Se omitido, <input type="number">, qualquer inteiro é válido, mas floats (como 4.2) não são válidos, porque step é padronizado como 1. Para 4.2 ser válido, step teria que ser definido como any, 0.1 , 0.2 ou qualquer valor mínimo teria que ser um número que terminasse em .2, como <input type="number" min="-5.2"> 

Nota:
  * Quando os dados inseridos pelo usuário não estão de acordo com a configuração de stepping,
    o valor é considerado inválido na validação da restrição e corresponderá à
    :invalid pseudoclass.

func (*TagInputWeek) Style 

func (e *TagInputWeek) Style(style string) (ref *TagInputWeek)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputWeek) TabIndex 

func (e *TagInputWeek) TabIndex(index int) (ref *TagInputWeek)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputWeek) Title 

func (e *TagInputWeek) Title(title string) (ref *TagInputWeek)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagInputWeek) Translate 

func (e *TagInputWeek) Translate(translate Translate) (ref *TagInputWeek)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagInputWeek) Type 

func (e *TagInputWeek) Type(inputType InputType) (ref *TagInputWeek)

Type

English: 

How an <input> works varies considerably depending on the value of its type attribute, hence the
different types are covered in their own separate reference pages.

If this attribute is not specified, the default type adopted is text.

Português: 

Como um <input> funciona varia consideravelmente dependendo do valor de seu atributo type,
portanto, os diferentes tipos são abordados em suas próprias páginas de referência separadas.

Se este atributo não for especificado, o tipo padrão adotado é texto.

func (*TagInputWeek) Value 

func (e *TagInputWeek) Value(value string) (ref *TagInputWeek)

Value

English: 

Defines the value associated with the element.

Português: 

Define o valor associado ao elemento.

type TagLabel 

type TagLabel struct {
	// contains filtered or unexported fields
}

func (*TagLabel) AccessKey 

func (e *TagLabel) AccessKey(key string) (ref *TagLabel)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagLabel) Append 

func (e *TagLabel) Append(append interface{}) (ref *TagLabel)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLabel) AppendById 

func (e *TagLabel) AppendById(appendId string) (ref *TagLabel)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLabel) Autofocus 

func (e *TagLabel) Autofocus(autofocus bool) (ref *TagLabel)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagLabel) Class 

func (e *TagLabel) Class(class ...string) (ref *TagLabel)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagLabel) ContentEditable 

func (e *TagLabel) ContentEditable(editable bool) (ref *TagLabel)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagLabel) CreateElement 

func (e *TagLabel) CreateElement(tag Tag) (ref *TagLabel)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagLabel) Data 

func (e *TagLabel) Data(data map[string]string) (ref *TagLabel)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagLabel) Dir 

func (e *TagLabel) Dir(dir Dir) (ref *TagLabel)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagLabel) Draggable 

func (e *TagLabel) Draggable(draggable Draggable) (ref *TagLabel)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagLabel) EnterKeyHint 

func (e *TagLabel) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagLabel)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagLabel) Form 

func (e *TagLabel) Form(form string) (ref *TagLabel)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagLabel) GetX 

func (e *TagLabel) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagLabel) GetXY 

func (e *TagLabel) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagLabel) GetY 

func (e *TagLabel) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagLabel) Hidden 

func (e *TagLabel) Hidden() (ref *TagLabel)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagLabel) Id 

func (e *TagLabel) Id(id string) (ref *TagLabel)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagLabel) InputMode 

func (e *TagLabel) InputMode(inputMode InputMode) (ref *TagLabel)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagLabel) Is 

func (e *TagLabel) Is(is string) (ref *TagLabel)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagLabel) ItemDrop 

func (e *TagLabel) ItemDrop(itemprop string) (ref *TagLabel)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagLabel) ItemId 

func (e *TagLabel) ItemId(id string) (ref *TagLabel)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagLabel) ItemRef 

func (e *TagLabel) ItemRef(itemref string) (ref *TagLabel)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagLabel) ItemType 

func (e *TagLabel) ItemType(itemType string) (ref *TagLabel)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagLabel) Lang 

func (e *TagLabel) Lang(language Language) (ref *TagLabel)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagLabel) Nonce 

func (e *TagLabel) Nonce(part ...string) (ref *TagLabel)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagLabel) SetX 

func (e *TagLabel) SetX(x int) (ref *TagLabel)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagLabel) SetXY 

func (e *TagLabel) SetXY(x, y int) (ref *TagLabel)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagLabel) SetY 

func (e *TagLabel) SetY(y int) (ref *TagLabel)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagLabel) Slot 

func (e *TagLabel) Slot(slot string) (ref *TagLabel)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagLabel) Spellcheck 

func (e *TagLabel) Spellcheck(spell bool) (ref *TagLabel)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagLabel) Style 

func (e *TagLabel) Style(style string) (ref *TagLabel)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLabel) TabIndex 

func (e *TagLabel) TabIndex(index int) (ref *TagLabel)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLabel) Title 

func (e *TagLabel) Title(title string) (ref *TagLabel)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLabel) Translate 

func (e *TagLabel) Translate(translate Translate) (ref *TagLabel)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagLegend 

type TagLegend struct {
	// contains filtered or unexported fields
}

func (*TagLegend) AccessKey 

func (e *TagLegend) AccessKey(key string) (ref *TagLegend)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagLegend) Append 

func (e *TagLegend) Append(append interface{}) (ref *TagLegend)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLegend) AppendById 

func (e *TagLegend) AppendById(appendId string) (ref *TagLegend)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagLegend) Autofocus 

func (e *TagLegend) Autofocus(autofocus bool) (ref *TagLegend)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagLegend) Class 

func (e *TagLegend) Class(class ...string) (ref *TagLegend)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagLegend) ContentEditable 

func (e *TagLegend) ContentEditable(editable bool) (ref *TagLegend)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagLegend) CreateElement 

func (e *TagLegend) CreateElement(tag Tag) (ref *TagLegend)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagLegend) Data 

func (e *TagLegend) Data(data map[string]string) (ref *TagLegend)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagLegend) Dir 

func (e *TagLegend) Dir(dir Dir) (ref *TagLegend)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagLegend) Draggable 

func (e *TagLegend) Draggable(draggable Draggable) (ref *TagLegend)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagLegend) EnterKeyHint 

func (e *TagLegend) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagLegend)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagLegend) GetX 

func (e *TagLegend) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagLegend) GetXY 

func (e *TagLegend) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagLegend) GetY 

func (e *TagLegend) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagLegend) Hidden 

func (e *TagLegend) Hidden() (ref *TagLegend)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagLegend) Id 

func (e *TagLegend) Id(id string) (ref *TagLegend)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagLegend) InputMode 

func (e *TagLegend) InputMode(inputMode InputMode) (ref *TagLegend)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagLegend) Is 

func (e *TagLegend) Is(is string) (ref *TagLegend)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagLegend) ItemDrop 

func (e *TagLegend) ItemDrop(itemprop string) (ref *TagLegend)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagLegend) ItemId 

func (e *TagLegend) ItemId(id string) (ref *TagLegend)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagLegend) ItemRef 

func (e *TagLegend) ItemRef(itemref string) (ref *TagLegend)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagLegend) ItemType 

func (e *TagLegend) ItemType(itemType string) (ref *TagLegend)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagLegend) Lang 

func (e *TagLegend) Lang(language Language) (ref *TagLegend)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagLegend) Nonce 

func (e *TagLegend) Nonce(part ...string) (ref *TagLegend)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagLegend) SetX 

func (e *TagLegend) SetX(x int) (ref *TagLegend)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagLegend) SetXY 

func (e *TagLegend) SetXY(x, y int) (ref *TagLegend)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagLegend) SetY 

func (e *TagLegend) SetY(y int) (ref *TagLegend)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagLegend) Slot 

func (e *TagLegend) Slot(slot string) (ref *TagLegend)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagLegend) Spellcheck 

func (e *TagLegend) Spellcheck(spell bool) (ref *TagLegend)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagLegend) Style 

func (e *TagLegend) Style(style string) (ref *TagLegend)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLegend) TabIndex 

func (e *TagLegend) TabIndex(index int) (ref *TagLegend)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLegend) Title 

func (e *TagLegend) Title(title string) (ref *TagLegend)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagLegend) Translate 

func (e *TagLegend) Translate(translate Translate) (ref *TagLegend)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagMeter 

type TagMeter struct {
	// contains filtered or unexported fields
}

func (*TagMeter) AccessKey 

func (e *TagMeter) AccessKey(key string) (ref *TagMeter)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagMeter) Append 

func (e *TagMeter) Append(append interface{}) (ref *TagMeter)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagMeter) AppendById 

func (e *TagMeter) AppendById(appendId string) (ref *TagMeter)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagMeter) Autofocus 

func (e *TagMeter) Autofocus(autofocus bool) (ref *TagMeter)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagMeter) Class 

func (e *TagMeter) Class(class ...string) (ref *TagMeter)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagMeter) ContentEditable 

func (e *TagMeter) ContentEditable(editable bool) (ref *TagMeter)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagMeter) CreateElement 

func (e *TagMeter) CreateElement(tag Tag) (ref *TagMeter)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagMeter) Data 

func (e *TagMeter) Data(data map[string]string) (ref *TagMeter)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagMeter) Dir 

func (e *TagMeter) Dir(dir Dir) (ref *TagMeter)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagMeter) Draggable 

func (e *TagMeter) Draggable(draggable Draggable) (ref *TagMeter)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagMeter) EnterKeyHint 

func (e *TagMeter) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagMeter)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagMeter) GetX 

func (e *TagMeter) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagMeter) GetXY 

func (e *TagMeter) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagMeter) GetY 

func (e *TagMeter) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagMeter) Hidden 

func (e *TagMeter) Hidden() (ref *TagMeter)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagMeter) High 

func (e *TagMeter) High(value float64) (ref *TagMeter)

High

English: 

The lower numeric bound of the high end of the measured range. This must be less than the maximum
value (max attribute), and it also must be greater than the low value and minimum value (low
attribute and min attribute, respectively), if any are specified. If unspecified, or if greater
than the maximum value, the high value is equal to the maximum value.

Português: 

O limite numérico inferior da extremidade superior do intervalo medido. Isso deve ser menor que o
valor máximo (atributo max) e também deve ser maior que o valor baixo e o valor mínimo (atributo
baixo e atributo min, respectivamente), se algum for especificado. Se não especificado, ou se for
maior que o valor máximo, o valor alto é igual ao valor máximo.

func (*TagMeter) Id 

func (e *TagMeter) Id(id string) (ref *TagMeter)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagMeter) InputMode 

func (e *TagMeter) InputMode(inputMode InputMode) (ref *TagMeter)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagMeter) Is 

func (e *TagMeter) Is(is string) (ref *TagMeter)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagMeter) ItemDrop 

func (e *TagMeter) ItemDrop(itemprop string) (ref *TagMeter)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagMeter) ItemId 

func (e *TagMeter) ItemId(id string) (ref *TagMeter)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagMeter) ItemRef 

func (e *TagMeter) ItemRef(itemref string) (ref *TagMeter)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagMeter) ItemType 

func (e *TagMeter) ItemType(itemType string) (ref *TagMeter)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagMeter) Lang 

func (e *TagMeter) Lang(language Language) (ref *TagMeter)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagMeter) Low 

func (e *TagMeter) Low(value float64) (ref *TagMeter)

Low

English: 

The upper numeric bound of the low end of the measured range. This must be greater than the
minimum value (min attribute), and it also must be less than the high value and maximum value
(high attribute and max attribute, respectively), if any are specified. If unspecified, or if
less than the minimum value, the low value is equal to the minimum value.

Português: 

O limite numérico superior da extremidade inferior do intervalo medido. Isso deve ser maior que o
valor mínimo (atributo min) e também deve ser menor que o valor alto e o valor máximo
(atributo alto e atributo max, respectivamente), se algum for especificado. Se não especificado,
ou se for menor que o valor mínimo, o valor baixo é igual ao valor mínimo.

func (*TagMeter) Max 

func (e *TagMeter) Max(value float64) (ref *TagMeter)

Max

English: 

The upper numeric bound of the measured range. This must be greater than the minimum value
(min attribute), if specified. If unspecified, the maximum value is 1.

Português: 

O limite numérico superior do intervalo medido. Deve ser maior que o valor mínimo
(atributo min), se especificado. Se não especificado, o valor máximo é 1.

func (*TagMeter) Min 

func (e *TagMeter) Min(value float64) (ref *TagMeter)

Min

English: 

The lower numeric bound of the measured range. This must be less than the maximum value
(max attribute), if specified. If unspecified, the minimum value is 0.

Português: 

O limite numérico inferior do intervalo medido. Isso deve ser menor que o valor máximo
(atributo max), se especificado. Se não especificado, o valor mínimo é 0.

func (*TagMeter) Nonce 

func (e *TagMeter) Nonce(part ...string) (ref *TagMeter)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagMeter) Optimum 

func (e *TagMeter) Optimum(value float64) (ref *TagMeter)

Optimum

English: 

This attribute indicates the optimal numeric value. It must be within the range (as defined by the
min attribute and max attribute). When used with the low attribute and high attribute, it gives an
indication where along the range is considered preferable. For example, if it is between the min
attribute and the low attribute, then the lower range is considered preferred. The browser may
color the meter's bar differently depending on whether the value is less than or equal to the
optimum value.

Português: 

Este atributo indica o valor numérico ideal. Deve estar dentro do intervalo (conforme definido
pelo atributo min e atributo max). Quando usado com o atributo baixo e o atributo alto, fornece
uma indicação de onde ao longo do intervalo é considerado preferível. Por exemplo, se estiver
entre o atributo min e o atributo low, o intervalo inferior será considerado preferencial.
O navegador pode colorir a barra do medidor de forma diferente dependendo se o valor é menor ou
igual ao valor ideal.

func (*TagMeter) SetX 

func (e *TagMeter) SetX(x int) (ref *TagMeter)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagMeter) SetXY 

func (e *TagMeter) SetXY(x, y int) (ref *TagMeter)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagMeter) SetY 

func (e *TagMeter) SetY(y int) (ref *TagMeter)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagMeter) Slot 

func (e *TagMeter) Slot(slot string) (ref *TagMeter)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagMeter) Spellcheck 

func (e *TagMeter) Spellcheck(spell bool) (ref *TagMeter)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagMeter) Style 

func (e *TagMeter) Style(style string) (ref *TagMeter)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagMeter) TabIndex 

func (e *TagMeter) TabIndex(index int) (ref *TagMeter)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagMeter) Title 

func (e *TagMeter) Title(title string) (ref *TagMeter)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagMeter) Translate 

func (e *TagMeter) Translate(translate Translate) (ref *TagMeter)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagMeter) Value 

func (e *TagMeter) Value(value float64) (ref *TagMeter)

Value

English: 

The current numeric value. This must be between the minimum and maximum values (min attribute and
max attribute) if they are specified. If unspecified or malformed, the value is 0. If specified,
but not within the range given by the min attribute and max attribute, the value is equal to the
nearest end of the range.

 Note:
   * Unless the value attribute is between 0 and 1 (inclusive), the min and max attributes should
     define the range so that the value attribute's value is within it.

Português: 

O valor numérico atual. Deve estar entre os valores mínimo e máximo (atributo min e atributo max)
se forem especificados. Se não especificado ou malformado, o valor é 0. Se especificado, mas não
dentro do intervalo fornecido pelos atributos min e max, o valor é igual à extremidade mais
próxima do intervalo.

 Nota:
   * A menos que o atributo value esteja entre 0 e 1 (inclusive), os atributos min e max devem
     definir o intervalo para que o valor do atributo value esteja dentro dele.

type TagOptionGroup 

type TagOptionGroup struct {
	// contains filtered or unexported fields
}

func (*TagOptionGroup) AccessKey 

func (e *TagOptionGroup) AccessKey(key string) (ref *TagOptionGroup)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagOptionGroup) Append 

func (e *TagOptionGroup) Append(append interface{}) (ref *TagOptionGroup)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOptionGroup) AppendById 

func (e *TagOptionGroup) AppendById(appendId string) (ref *TagOptionGroup)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOptionGroup) Autofocus 

func (e *TagOptionGroup) Autofocus(autofocus bool) (ref *TagOptionGroup)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagOptionGroup) Class 

func (e *TagOptionGroup) Class(class ...string) (ref *TagOptionGroup)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagOptionGroup) ContentEditable 

func (e *TagOptionGroup) ContentEditable(editable bool) (ref *TagOptionGroup)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagOptionGroup) CreateElement 

func (e *TagOptionGroup) CreateElement(tag Tag) (ref *TagOptionGroup)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagOptionGroup) Data 

func (e *TagOptionGroup) Data(data map[string]string) (ref *TagOptionGroup)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagOptionGroup) Dir 

func (e *TagOptionGroup) Dir(dir Dir) (ref *TagOptionGroup)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagOptionGroup) Disabled 

func (e *TagOptionGroup) Disabled(disabled bool) (ref *TagOptionGroup)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagOptionGroup) Draggable 

func (e *TagOptionGroup) Draggable(draggable Draggable) (ref *TagOptionGroup)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagOptionGroup) EnterKeyHint 

func (e *TagOptionGroup) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagOptionGroup)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagOptionGroup) GetX 

func (e *TagOptionGroup) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagOptionGroup) GetXY 

func (e *TagOptionGroup) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagOptionGroup) GetY 

func (e *TagOptionGroup) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagOptionGroup) Hidden 

func (e *TagOptionGroup) Hidden() (ref *TagOptionGroup)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagOptionGroup) Id 

func (e *TagOptionGroup) Id(id string) (ref *TagOptionGroup)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagOptionGroup) InputMode 

func (e *TagOptionGroup) InputMode(inputMode InputMode) (ref *TagOptionGroup)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagOptionGroup) Is 

func (e *TagOptionGroup) Is(is string) (ref *TagOptionGroup)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagOptionGroup) ItemDrop 

func (e *TagOptionGroup) ItemDrop(itemprop string) (ref *TagOptionGroup)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagOptionGroup) ItemId 

func (e *TagOptionGroup) ItemId(id string) (ref *TagOptionGroup)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagOptionGroup) ItemRef 

func (e *TagOptionGroup) ItemRef(itemref string) (ref *TagOptionGroup)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagOptionGroup) ItemType 

func (e *TagOptionGroup) ItemType(itemType string) (ref *TagOptionGroup)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagOptionGroup) Label 

func (e *TagOptionGroup) Label(label string) (ref *TagOptionGroup)

Label

English: 

The name of the group of options, which the browser can use when labeling the options in the user
interface. This attribute is mandatory if this element is used.

Português: 

O nome do grupo de opções, que o navegador pode usar ao rotular as opções na interface do usuário.
Este atributo é obrigatório se este elemento for usado.

func (*TagOptionGroup) Lang 

func (e *TagOptionGroup) Lang(language Language) (ref *TagOptionGroup)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagOptionGroup) Nonce 

func (e *TagOptionGroup) Nonce(part ...string) (ref *TagOptionGroup)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagOptionGroup) SetX 

func (e *TagOptionGroup) SetX(x int) (ref *TagOptionGroup)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagOptionGroup) SetXY 

func (e *TagOptionGroup) SetXY(x, y int) (ref *TagOptionGroup)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagOptionGroup) SetY 

func (e *TagOptionGroup) SetY(y int) (ref *TagOptionGroup)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagOptionGroup) Slot 

func (e *TagOptionGroup) Slot(slot string) (ref *TagOptionGroup)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagOptionGroup) Spellcheck 

func (e *TagOptionGroup) Spellcheck(spell bool) (ref *TagOptionGroup)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagOptionGroup) Style 

func (e *TagOptionGroup) Style(style string) (ref *TagOptionGroup)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOptionGroup) TabIndex 

func (e *TagOptionGroup) TabIndex(index int) (ref *TagOptionGroup)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOptionGroup) Title 

func (e *TagOptionGroup) Title(title string) (ref *TagOptionGroup)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOptionGroup) Translate 

func (e *TagOptionGroup) Translate(translate Translate) (ref *TagOptionGroup)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagOutput 

type TagOutput struct {
	// contains filtered or unexported fields
}

func (*TagOutput) AccessKey 

func (e *TagOutput) AccessKey(key string) (ref *TagOutput)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagOutput) Append 

func (e *TagOutput) Append(append interface{}) (ref *TagOutput)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOutput) AppendById 

func (e *TagOutput) AppendById(appendId string) (ref *TagOutput)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagOutput) Autofocus 

func (e *TagOutput) Autofocus(autofocus bool) (ref *TagOutput)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagOutput) Class 

func (e *TagOutput) Class(class ...string) (ref *TagOutput)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagOutput) ContentEditable 

func (e *TagOutput) ContentEditable(editable bool) (ref *TagOutput)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagOutput) CreateElement 

func (e *TagOutput) CreateElement(tag Tag) (ref *TagOutput)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagOutput) Data 

func (e *TagOutput) Data(data map[string]string) (ref *TagOutput)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagOutput) Dir 

func (e *TagOutput) Dir(dir Dir) (ref *TagOutput)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagOutput) Draggable 

func (e *TagOutput) Draggable(draggable Draggable) (ref *TagOutput)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagOutput) EnterKeyHint 

func (e *TagOutput) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagOutput)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagOutput) For 

func (e *TagOutput) For(value string) (ref *TagOutput)

For

English: 

The value of the for attribute must be a single id for a labelable form-related element in the
same document as the <label> element. So, any given label element can be associated with only
one form control.

 Note:
   * To programmatically set the for attribute, use htmlFor.

The first element in the document with an id attribute matching the value of the for attribute is the labeled control for this label element — if the element with that id is actually a labelable element. If it is not a labelable element, then the for attribute has no effect. If there are other elements that also match the id value, later in the document, they are not considered.

Multiple label elements can be given the same value for their for attribute; doing so causes the associated form control (the form control that for value references) to have multiple labels. 

Note:
  * A <label> element can have both a for attribute and a contained control element, as long as
    the for attribute points to the contained control element.

Português: 

O valor do atributo for deve ser um único id para um elemento rotulável relacionado ao formulário
no mesmo documento que o elemento <label>. Portanto, qualquer elemento de rótulo pode ser
associado a apenas um controle de formulário.

 Nota:
   * Programaticamente definir o atributo for, use htmlFor.

O primeiro elemento no documento com um atributo id correspondente ao valor do atributo é o controle rotulado para este elemento label - se o elemento com esse ID é realmente um elemento labelable. Se não é um elemento labelable, em seguida, o atributo for tem nenhum efeito. Se existem outros elementos que também correspondem ao valor id, mais adiante no documento, eles não são considerados.

Vários elementos de rótulo podem receber o mesmo valor para seu atributo for; isso faz com que o controle de formulário associado (o controle de formulário para referências de valor) tenha vários rótulos. 

Nota:
  * Um elemento <label> pode ter um atributo for e um elemento de controle contido, desde que
    o atributo for aponte para o elemento de controle contido.

func (*TagOutput) Form 

func (e *TagOutput) Form(form string) (ref *TagOutput)

Form

English: 

The <form> element to associate the output with (its form owner). The value of this attribute must
be the id of a <form> in the same document.

 Note:
   * If this attribute is not set, the <output> is associated with its ancestor <form> element,
     if any;
   * This attribute lets you associate <output> elements to <form>s anywhere in the document, not
     just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar a saída (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento.

 Nota:
   * Se este atributo não for definido, o <output> será associado ao elemento <form> ancestral,
     se houver;
   * Este atributo permite associar elementos <output> a <form>s em qualquer lugar do documento,
     não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagOutput) GetX 

func (e *TagOutput) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagOutput) GetXY 

func (e *TagOutput) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagOutput) GetY 

func (e *TagOutput) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagOutput) Hidden 

func (e *TagOutput) Hidden() (ref *TagOutput)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagOutput) Id 

func (e *TagOutput) Id(id string) (ref *TagOutput)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagOutput) InputMode 

func (e *TagOutput) InputMode(inputMode InputMode) (ref *TagOutput)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagOutput) Is 

func (e *TagOutput) Is(is string) (ref *TagOutput)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagOutput) ItemDrop 

func (e *TagOutput) ItemDrop(itemprop string) (ref *TagOutput)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagOutput) ItemId 

func (e *TagOutput) ItemId(id string) (ref *TagOutput)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagOutput) ItemRef 

func (e *TagOutput) ItemRef(itemref string) (ref *TagOutput)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagOutput) ItemType 

func (e *TagOutput) ItemType(itemType string) (ref *TagOutput)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagOutput) Lang 

func (e *TagOutput) Lang(language Language) (ref *TagOutput)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagOutput) Name 

func (e *TagOutput) Name(name string) (ref *TagOutput)

Name

English: 

The element's name. Used in the form.elements API.

Português: 

O nome do elemento. Usado na API form.elements.

func (*TagOutput) Nonce 

func (e *TagOutput) Nonce(part ...string) (ref *TagOutput)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagOutput) SetX 

func (e *TagOutput) SetX(x int) (ref *TagOutput)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagOutput) SetXY 

func (e *TagOutput) SetXY(x, y int) (ref *TagOutput)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagOutput) SetY 

func (e *TagOutput) SetY(y int) (ref *TagOutput)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagOutput) Slot 

func (e *TagOutput) Slot(slot string) (ref *TagOutput)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagOutput) Spellcheck 

func (e *TagOutput) Spellcheck(spell bool) (ref *TagOutput)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagOutput) Style 

func (e *TagOutput) Style(style string) (ref *TagOutput)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOutput) TabIndex 

func (e *TagOutput) TabIndex(index int) (ref *TagOutput)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOutput) Title 

func (e *TagOutput) Title(title string) (ref *TagOutput)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagOutput) Translate 

func (e *TagOutput) Translate(translate Translate) (ref *TagOutput)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagSelect 

type TagSelect struct {
	// contains filtered or unexported fields
}

func (*TagSelect) AccessKey 

func (e *TagSelect) AccessKey(key string) (ref *TagSelect)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagSelect) Append 

func (e *TagSelect) Append(append interface{}) (ref *TagSelect)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagSelect) AppendById 

func (e *TagSelect) AppendById(appendId string) (ref *TagSelect)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagSelect) Autocomplete 

func (e *TagSelect) Autocomplete(autocomplete Autocomplete) (ref *TagSelect)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagSelect) Autofocus 

func (e *TagSelect) Autofocus(autofocus bool) (ref *TagSelect)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagSelect) Class 

func (e *TagSelect) Class(class ...string) (ref *TagSelect)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagSelect) ContentEditable 

func (e *TagSelect) ContentEditable(editable bool) (ref *TagSelect)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagSelect) CreateElement 

func (e *TagSelect) CreateElement(tag Tag) (ref *TagSelect)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagSelect) Data 

func (e *TagSelect) Data(data map[string]string) (ref *TagSelect)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagSelect) Dir 

func (e *TagSelect) Dir(dir Dir) (ref *TagSelect)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagSelect) Disabled 

func (e *TagSelect) Disabled(disabled bool) (ref *TagSelect)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagSelect) Draggable 

func (e *TagSelect) Draggable(draggable Draggable) (ref *TagSelect)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagSelect) EnterKeyHint 

func (e *TagSelect) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagSelect)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagSelect) Form 

func (e *TagSelect) Form(form string) (ref *TagSelect)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagSelect) GetX 

func (e *TagSelect) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagSelect) GetXY 

func (e *TagSelect) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagSelect) GetY 

func (e *TagSelect) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagSelect) Hidden 

func (e *TagSelect) Hidden() (ref *TagSelect)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagSelect) Id 

func (e *TagSelect) Id(id string) (ref *TagSelect)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagSelect) InputMode 

func (e *TagSelect) InputMode(inputMode InputMode) (ref *TagSelect)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagSelect) Is 

func (e *TagSelect) Is(is string) (ref *TagSelect)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagSelect) ItemDrop 

func (e *TagSelect) ItemDrop(itemprop string) (ref *TagSelect)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagSelect) ItemId 

func (e *TagSelect) ItemId(id string) (ref *TagSelect)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagSelect) ItemRef 

func (e *TagSelect) ItemRef(itemref string) (ref *TagSelect)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagSelect) ItemType 

func (e *TagSelect) ItemType(itemType string) (ref *TagSelect)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagSelect) Lang 

func (e *TagSelect) Lang(language Language) (ref *TagSelect)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagSelect) Multiple 

func (e *TagSelect) Multiple(multiple bool) (ref *TagSelect)

Multiple

English: 

This Boolean attribute indicates that multiple options can be selected in the list. If it is not
specified, then only one option can be selected at a time. When multiple is specified, most
browsers will show a scrolling list box instead of a single line dropdown.

Português: 

Este atributo booleano indica que várias opções podem ser selecionadas na lista. Se não for
especificado, apenas uma opção pode ser selecionada por vez. Quando vários são especificados, a
maioria dos navegadores mostrará uma caixa de listagem de rolagem em vez de uma lista suspensa
de uma única linha.

func (*TagSelect) Name 

func (e *TagSelect) Name(name string) (ref *TagSelect)

Name

English: 

The name of the button, submitted as a pair with the button's value as part of the form data,
when that button is used to submit the form.

Português: 

O nome do botão, enviado como um par com o valor do botão como parte dos dados do formulário,
quando esse botão é usado para enviar o formulário.

func (*TagSelect) NewOption 

func (e *TagSelect) NewOption(id, label, value string, disabled, selected bool) (ref *TagSelect)

NewOption

English: 

The <option> HTML element is used to define an item contained in a <select>, an <optgroup>, or
a <datalist> element. As such, <option> can represent menu items in popups and other lists of
items in an HTML document.

 Input:
   id: a unique id for an element;
   label: This attribute is text for the label indicating the meaning of the option. If the label
     attribute isn't defined, its value is that of the element text content;
   value: The content of this attribute represents the value to be submitted with the form, should
     this option be selected. If this attribute is omitted, the value is taken from the text
     content of the option element;
   disabled: If this Boolean attribute is set, this option is not checkable. Often browsers grey
     out such control and it won't receive any browsing event, like mouse clicks or focus-related
     ones. If this attribute is not set, the element can still be disabled if one of its ancestors
     is a disabled <optgroup> element;
   selected: If present, this Boolean attribute indicates that the option is initially selected.
     If the <option> element is the descendant of a <select> element whose multiple attribute is
     not set, only one single <option> of this <select> element may have the selected attribute.

 Nota:
   * The new option will be created inside the last NewOptionGroup() created. Use the
     ReleaseGroup() function to create the new option at the root.

Português: 

O elemento HTML <option> é usado para definir um item contido em um elemento <select>, <optgroup>
ou <datalist>. Como tal, <option> pode representar itens de menu em pop-ups e outras listas de
itens em um documento HTML.

 Entrada:
   id: um id exclusivo para um elemento;
   label: Este atributo é um texto para o rótulo que indica o significado da opção. Se o atributo
     label não estiver definido, seu valor será o do conteúdo do texto do elemento;
   value: O conteúdo deste atributo representa o valor a ser enviado com o formulário, caso esta
     opção seja selecionada. Se este atributo for omitido, o valor será obtido do conteúdo de
     texto do elemento de opção;
   disabled: Se este atributo booleano estiver definido, esta opção não poderá ser marcada.
     Muitas vezes, os navegadores desativam esse controle e não recebem nenhum evento de
     navegação, como cliques do mouse ou relacionados ao foco. Se este atributo não for definido,
     o elemento ainda poderá ser desabilitado se um de seus ancestrais for um elemento <optgroup>
     desabilitado;
   selected: Se presente, este atributo booleano indica que a opção foi selecionada inicialmente.
     Se o elemento <option> é descendente de um elemento <select> cujo atributo múltiplo não está
     definido, apenas um único <option> deste elemento <select> pode ter o atributo selecionado.

 Nota:
   * O novo option será criado dentro do último NewOptionGroup() criado. Use a função
     ReleaseGroup() para criar o novo option na raiz.

func (*TagSelect) NewOptionGroup 

func (e *TagSelect) NewOptionGroup(id, label string, disabled bool) (ref *TagSelect)

func (*TagSelect) Nonce 

func (e *TagSelect) Nonce(part ...string) (ref *TagSelect)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagSelect) ReleaseGroup 

func (e *TagSelect) ReleaseGroup() (ref *TagSelect)

ReleaseGroup

English: 

Releases the new option from the last option group created.

Português: 

Libera o novo option do último option group criado.

func (*TagSelect) Required 

func (e *TagSelect) Required(required bool) (ref *TagSelect)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagSelect) SetX 

func (e *TagSelect) SetX(x int) (ref *TagSelect)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagSelect) SetXY 

func (e *TagSelect) SetXY(x, y int) (ref *TagSelect)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagSelect) SetY 

func (e *TagSelect) SetY(y int) (ref *TagSelect)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagSelect) Size 

func (e *TagSelect) Size(size int) (ref *TagSelect)

Size

English: 

If the control is presented as a scrolling list box (e.g. when multiple is specified), this
attribute represents the number of rows in the list that should be visible at one time.
Browsers are not required to present a select element as a scrolled list box. The default value
is 0.

 Note:
   * According to the HTML5 specification, the default value for size should be 1; however, in
     practice, this has been found to break some web sites, and no other browser currently does
     that, so Mozilla has opted to continue to return 0 for the time being with Firefox.

Português: 

Se o controle for apresentado como uma caixa de listagem de rolagem (por exemplo, quando múltiplo
é especificado), esse atributo representa o número de linhas na lista que devem estar visíveis ao
mesmo tempo. Os navegadores não precisam apresentar um elemento de seleção como uma caixa de
listagem rolada. O valor padrão é 0.

 Nota:
   * De acordo com a especificação HTML5, o valor padrão para tamanho deve ser 1; no entanto, na
     prática, descobriu-se que isso quebra alguns sites, e nenhum outro navegador atualmente faz
     isso, então a Mozilla optou por continuar retornando 0 por enquanto com o Firefox.

func (*TagSelect) Slot 

func (e *TagSelect) Slot(slot string) (ref *TagSelect)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagSelect) Spellcheck 

func (e *TagSelect) Spellcheck(spell bool) (ref *TagSelect)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagSelect) Style 

func (e *TagSelect) Style(style string) (ref *TagSelect)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagSelect) TabIndex 

func (e *TagSelect) TabIndex(index int) (ref *TagSelect)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagSelect) Title 

func (e *TagSelect) Title(title string) (ref *TagSelect)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagSelect) Translate 

func (e *TagSelect) Translate(translate Translate) (ref *TagSelect)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

type TagTextArea 

type TagTextArea struct {
	// contains filtered or unexported fields
}

func (*TagTextArea) AccessKey 

func (e *TagTextArea) AccessKey(key string) (ref *TagTextArea)

AccessKey

English: 

Specifies a shortcut key to activate/focus an element.

 Input:
   character: A single character that specifies the shortcut key to activate/focus the element.

 Note:
   * The accessKey attribute value must be a single character (a letter or a digit).
   * Adapting accessKeys to all international languages are difficult.
   * The accessKey value may not be present on all keyboards.

 Warning:
   Using accessKeys is difficult because they may conflict with other key standards in the
   browser;
   To avoid this problem, most browsers will use accessKeys only if pressed together with the Alt
   key.

Português: 

Especifica uma tecla de atalho para ativar o foco de um elemento.

 Entrada:
   character: Um único caractere que especifica a tecla de atalho para ativar o foco do elemento.

 Nota:
   * O valor do atributo accessKey deve ser um único caractere (uma letra ou um dígito).
   * Adaptar as teclas de acesso a todos os idiomas internacionais é difícil.
   * O valor accessKey pode não estar presente em todos os teclados.

 Aviso:
   O uso de accessKeys é difícil porque eles podem entrar em conflito com outros padrões
   importantes no navegador;
   Para evitar esse problema, a maioria dos navegadores usará as teclas de acesso somente se
   pressionadas junto com a tecla Alt.

func (*TagTextArea) Append 

func (e *TagTextArea) Append(append interface{}) (ref *TagTextArea)

Append

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the new
parent.

 Input:
   append: element in js.Value format.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: elemento no formato js.Value.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagTextArea) AppendById 

func (e *TagTextArea) AppendById(appendId string) (ref *TagTextArea)

AppendById

English: 

Adds a node to the end of the list of children of a specified parent node. If the node already
exists in the document, it is removed from its current parent node before being added to the
new parent.

 Input:
   appendId: id of parent element.

 Note:
   * The equivalent of:
       var p = document.createElement("p");
       document.body.appendChild(p);

Português: 

Adiciona um nó ao final da lista de filhos de um nó pai especificado. Se o nó já existir no
documento, ele é removido de seu nó pai atual antes de ser adicionado ao novo pai.

 Entrada:
   appendId: id do elemento pai.

 Nota:
   * Equivale a:
       var p = document.createElement("p");
       document.body.appendChild(p);

func (*TagTextArea) Autocomplete 

func (e *TagTextArea) Autocomplete(autocomplete Autocomplete) (ref *TagTextArea)

Autocomplete

English: 

The HTML autocomplete attribute lets web developers specify what if any permission the user agent
has to provide automated assistance in filling out form field values, as well as guidance to the
browser as to the type of information expected in the field.

It is available on <input> elements that take a text or numeric value as input, <textarea> elements, <select> elements, and <form> elements.

The source of the suggested values is generally up to the browser; typically values come from past values entered by the user, but they may also come from pre-configured values. For instance, a browser might let the user save their name, address, phone number, and email addresses for autocomplete purposes. Perhaps the browser offers the ability to save encrypted credit card information, for autocompletion following an authentication procedure.

If an <input>, <select> or <textarea> element has no autocomplete attribute, then browsers use the autocomplete attribute of the element's form owner, which is either the <form> element that the element is a descendant of, or the <form> whose id is specified by the form attribute of the element. 

Note:
  * In order to provide autocompletion, user-agents might require <input>/<select>/<textarea>
    elements to:
      Have a name and/or id attribute;
      Be descendants of a <form> element;
      The form to have a submit button.

Português: 

O atributo autocomplete HTML permite que os desenvolvedores da Web especifiquem se existe alguma
permissão que o agente do usuário tenha para fornecer assistência automatizada no preenchimento
dos valores dos campos do formulário, bem como orientação ao navegador quanto ao tipo de
informação esperado no campo.

Ele está disponível em elementos <input> que recebem um texto ou valor numérico como entrada, elementos <textarea>, elementos <select> e elementos <form>.

A origem dos valores sugeridos geralmente depende do navegador; normalmente os valores vêm de valores passados inseridos pelo usuário, mas também podem vir de valores pré-configurados. Por exemplo, um navegador pode permitir que o usuário salve seu nome, endereço, número de telefone e endereços de e-mail para fins de preenchimento automático. Talvez o navegador ofereça a capacidade de salvar informações de cartão de crédito criptografadas, para preenchimento automático após um procedimento de autenticação.

Se um elemento <input>, <select> ou <textarea> não tiver um atributo autocomplete, os navegadores usarão o atributo autocomplete do proprietário do formulário do elemento, que é o elemento <form> do qual o elemento é descendente ou o < form> cujo id é especificado pelo atributo form do elemento. 

Nota:
  * Para fornecer preenchimento automático, os agentes do usuário podem exigir elementos
    <input> / <select> / <textarea> para:
      Ter um atributo name e ou id;
      Ser descendentes de um elemento <form>;
      O formulário para ter um botão de envio.

func (*TagTextArea) Autofocus 

func (e *TagTextArea) Autofocus(autofocus bool) (ref *TagTextArea)

Autofocus

English: 

This Boolean attribute specifies that the button should have input focus when the page loads.
Only one element in a document can have this attribute.

Português: 

Este atributo booleano especifica que o botão deve ter foco de entrada quando a página for
carregada. Apenas um elemento em um documento pode ter esse atributo.

func (*TagTextArea) Class 

func (e *TagTextArea) Class(class ...string) (ref *TagTextArea)

Class

English: 

The class attribute specifies one or more class names for an element.

 Input:
   classname: Specifies one or more class names for an element. To specify multiple classes,
              separate the class names with a space, e.g. <span class="left important">.
              This allows you to combine several CSS classes for one HTML element.

              Naming rules:
                Must begin with a letter A-Z or a-z;
                Can be followed by: letters (A-Za-z), digits (0-9), hyphens ("-"), and
                underscores ("_").

The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class.

Português: 

O atributo class especifica um ou mais nomes de classe para um elemento.

 Entrada:
   classname: Especifica um ou mais nomes de classe para um elemento. Para especificar várias
              classes, separe os nomes das classes com um espaço, por exemplo <span class="left
              important">.
              Isso permite combinar várias classes CSS para um elemento HTML.

              Regras de nomenclatura:
                Deve começar com uma letra A-Z ou a-z;
                Pode ser seguido por: letras (A-Za-z), dígitos (0-9), hífens ("-") e
                sublinhados ("_").

O atributo class é usado principalmente para apontar para uma classe em uma folha de estilo. No entanto, também pode ser usado por um JavaScript (através do HTML DOM) para fazer alterações em elementos HTML com uma classe especificada.

func (*TagTextArea) Cols 

func (e *TagTextArea) Cols(cols int) (ref *TagTextArea)

Cols

English: 

The visible width of the text control, in average character widths.

 Note:
   * If it is not specified, the default value is 20;
   * If it is specified, it must be a positive integer.

Português: 

A largura visível do controle de texto, em larguras médias de caracteres.

 Note:
   * Se não for especificado, o valor padrão é 20;
   * Se for especificado, deve ser um número inteiro positivo.

func (*TagTextArea) ContentEditable 

func (e *TagTextArea) ContentEditable(editable bool) (ref *TagTextArea)

ContentEditable

English: 

The contentEditable attribute specifies whether the content of an element is editable or not.

 Input:
   contentEditable: specifies whether the content of an element is editable or not

 Note:
   When the contentEditable attribute is not set on an element, the element will inherit it from
   its parent.

Português: 

O atributo contentEditable especifica se o conteúdo de um elemento é editável ou não.

 Entrada:
   contentEditable: especifica se o conteúdo de um elemento é editável ou não.

 Nota:
   Quando o atributo contentEditable não está definido em um elemento, o elemento o herdará de
   seu pai.

func (*TagTextArea) CreateElement 

func (e *TagTextArea) CreateElement(tag Tag) (ref *TagTextArea)

CreateElement

English: 

In an HTML document, the Document.createElement() method creates the specified HTML element or an
HTMLUnknownElement if the given element name is not known.

Português: 

Em um documento HTML, o método Document.createElement() cria o elemento HTML especificado ou um
HTMLUnknownElement se o nome do elemento dado não for conhecido.

func (*TagTextArea) Data 

func (e *TagTextArea) Data(data map[string]string) (ref *TagTextArea)

Data

English: 

Used to store custom data private to the page or application.

 Input:
   data: custom data private to the page or application.

The data-* attributes is used to store custom data private to the page or application. The data-* attributes gives us the ability to embed custom data attributes on all HTML elements. The stored (custom) data can then be used in the page's JavaScript to create a more engaging user experience (without any Ajax calls or server-side database queries).

The data-* attributes consist of two parts: 

The attribute name should not contain any uppercase letters, and must be at least one character
long after the prefix "data-";
The attribute value can be any string.

Note:
  * Custom attributes prefixed with "data-" will be completely ignored by the user agent.

Português: 

Usado para armazenar dados personalizados privados para a página ou aplicativo.

 Entrada:
   data: dados personalizados privados para a página ou aplicativo.

Os atributos de dados são usados para armazenar dados personalizados privados para a página ou aplicativo; Os atributos de dados nos dão a capacidade de incorporar atributos de dados personalizados em todos os elementos HTML; Os dados armazenados (personalizados) podem ser usados no JavaScript da página para criar uma experiência de usuário mais envolvente (sem chamadas Ajax ou consultas de banco de dados do lado do servidor).

Os atributos de dados consistem em duas partes: 

O nome do atributo não deve conter letras maiúsculas e deve ter pelo menos um caractere após o
prefixo "data-";
O valor do atributo pode ser qualquer string.

Nota:
  * Atributos personalizados prefixados com "data-" serão completamente ignorados pelo agente do
    usuário.

func (*TagTextArea) Dir 

func (e *TagTextArea) Dir(dir Dir) (ref *TagTextArea)

Dir

English: 

Specifies the text direction for the content in an element.

 Input:
   dir: direction for the content in an element. [ KDirLeftToRight | KDirRightToLeft | KDirAuto ]

Português: 

Especifica a direção do texto para o conteúdo em um elemento.

 Entrada:
   dir: direção do texto para o conteúdo em um elemento. [ KDirLeftToRight | KDirRightToLeft |
        KDirAuto ]

func (*TagTextArea) Disabled 

func (e *TagTextArea) Disabled(disabled bool) (ref *TagTextArea)

Disabled

English: 

Este atributo booleano impede que o usuário interaja com o elemento.

Português: 

Este atributo booleano impede que o usuário interaja com o elemento.

func (*TagTextArea) Draggable 

func (e *TagTextArea) Draggable(draggable Draggable) (ref *TagTextArea)

Draggable

English: 

Specifies whether an element is draggable or not.

 Input:
   draggable: element is draggable or not. [ KDraggableYes | KDraggableNo | KDraggableAuto ]

The draggable attribute specifies whether an element is draggable or not. 

Note:
  * Links and images are draggable by default;
  * The draggable attribute is often used in drag and drop operations.
  * Read our HTML Drag and Drop tutorial to learn more.
    https://www.w3schools.com/html/html5_draganddrop.asp

Português: 

Especifica se um elemento pode ser arrastado ou não. [ KDraggableYes | KDraggableNo |
KDraggableAuto ]

 Entrada:
   draggable: elemento é arrastável ou não.

O atributo arrastável especifica se um elemento é arrastável ou não. 

Nota:
  * Links e imagens podem ser arrastados por padrão;
  * O atributo arrastável é frequentemente usado em operações de arrastar e soltar.
  * Leia nosso tutorial de arrastar e soltar HTML para saber mais.
    https://www.w3schools.com/html/html5_draganddrop.asp

func (*TagTextArea) EnterKeyHint 

func (e *TagTextArea) EnterKeyHint(enterKeyHint EnterKeyHint) (ref *TagTextArea)

EnterKeyHint

English: 

The enterKeyHint property is an enumerated property defining what action label (or icon) to
present for the enter key on virtual keyboards. It reflects the enterkeyhint HTML global attribute
and is an enumerated property, only accepting the following values as a DOMString:

 Input:
   enterKeyHint: defining what action label (or icon) to present for the enter key on virtual
     keyboards
     KEnterKeyHintEnter: typically indicating inserting a new line.
     KEnterKeyHintDone: typically meaning there is nothing more to input and the input method
      editor (IME) will be closed.
     KEnterKeyHintGo: typically meaning to take the user to the target of the text they typed.
     KEnterKeyHintNext: typically taking the user to the next field that will accept text.
     KEnterKeyHintPrevious: typically taking the user to the previous field that will accept text.
     KEnterKeyHintSearch: typically taking the user to the results of searching for the text they
       have typed.
     KEnterKeyHintSend: typically delivering the text to its target.

If no enterKeyHint value has been specified or if it was set to a different value than the allowed ones, it will return an empty string.

Português: 

A propriedade enterKeyHint é uma propriedade enumerada que define qual rótulo de ação (ou ícone)
apresentar para a tecla Enter em teclados virtuais. Ele reflete o atributo global enterkeyhint
HTML e é uma propriedade enumerada, aceitando apenas os seguintes valores como DOMString:

 Entrada:
   enterKeyHint: definindo qual rótulo de ação (ou ícone) apresentar para a tecla Enter em
     teclados virtuais
     KEnterKeyHintEnter: normalmente indicando a inserção de uma nova linha.
     KEnterKeyHintDone: normalmente significa que não há mais nada para inserir e o editor de
       método de entrada (IME) será fechado.
     KEnterKeyHintGo: normalmente significando levar o usuário ao destino do texto digitado.
     KEnterKeyHintNext: normalmente levando o usuário para o próximo campo que aceitará texto.
     KEnterKeyHintPrevious: normalmente levando o usuário ao campo anterior que aceitará texto.
     KEnterKeyHintSearch: normalmente levando o usuário aos resultados da pesquisa do texto que
       digitou.
     KEnterKeyHintSend: normalmente entregando o texto ao seu destino.

Se nenhum valor enterKeyHint foi especificado ou se foi definido com um valor diferente dos permitidos, ele retornará uma string vazia.

func (*TagTextArea) Form 

func (e *TagTextArea) Form(form string) (ref *TagTextArea)

Form

English: 

The <form> element to associate the button with (its form owner). The value of this attribute must
be the id of a <form> in the same document. (If this attribute is not set, the <button> is
associated with its ancestor <form> element, if any.)

This attribute lets you associate <button> elements to <form>s anywhere in the document, not just inside a <form>. It can also override an ancestor <form> element.

Português: 

O elemento <form> ao qual associar o botão (seu proprietário do formulário). O valor deste
atributo deve ser o id de um <form> no mesmo documento. (Se esse atributo não for definido, o
<button> será associado ao elemento <form> ancestral, se houver.)

Este atributo permite associar elementos <button> a <form>s em qualquer lugar do documento, não apenas dentro de um <form>. Ele também pode substituir um elemento <form> ancestral.

func (*TagTextArea) GetX 

func (e *TagTextArea) GetX() (x int)

GetX

English: 

Returns the X axe in pixels.

Português: 

Retorna o eixo X em pixels.

func (*TagTextArea) GetXY 

func (e *TagTextArea) GetXY() (x, y int)

GetXY

English: 

Returns the X and Y axes in pixels.

Português: 

Retorna os eixos X e Y em pixels.

func (*TagTextArea) GetY 

func (e *TagTextArea) GetY() (y int)

GetY

English: 

Returns the Y axe in pixels.

Português: 

Retorna o eixo Y em pixels.

func (*TagTextArea) Hidden 

func (e *TagTextArea) Hidden() (ref *TagTextArea)

Hidden

English: 

Specifies that an element is not yet, or is no longer, relevant.

 Input:
   hidden:

The hidden attribute is a boolean attribute.

When present, it specifies that an element is not yet, or is no longer, relevant.

Browsers should not display elements that have the hidden attribute specified.

The hidden attribute can also be used to keep a user from seeing an element until some other condition has been met (like selecting a checkbox, etc.). Then, a JavaScript could remove the hidden attribute, and make the element visible.

Português: 

Especifica que um elemento ainda não é ou não é mais relevante.

O atributo oculto é um atributo booleano.

Quando presente, especifica que um elemento ainda não é ou não é mais relevante.

Os navegadores não devem exibir elementos que tenham o atributo oculto especificado.

O atributo oculto também pode ser usado para impedir que um usuário veja um elemento até que alguma outra condição seja atendida (como marcar uma caixa de seleção etc.). Então, um JavaScript pode remover o atributo oculto e tornar o elemento visível.

func (*TagTextArea) Id 

func (e *TagTextArea) Id(id string) (ref *TagTextArea)

Id

English: 

Specifies a unique id for an element

The id attribute specifies a unique id for an HTML element (the value must be unique within the HTML document).

The id attribute is most used to point to a style in a style sheet, and by JavaScript (via the HTML DOM) to manipulate the element with the specific id.

Português: 

Especifica um ID exclusivo para um elemento

O atributo id especifica um id exclusivo para um elemento HTML (o valor deve ser exclusivo no documento HTML).

O atributo id é mais usado para apontar para um estilo em uma folha de estilo, e por JavaScript (através do HTML DOM) para manipular o elemento com o id específico.

func (*TagTextArea) InputMode 

func (e *TagTextArea) InputMode(inputMode InputMode) (ref *TagTextArea)

InputMode

English: 

The inputmode global attribute is an enumerated attribute that hints at the type of data that
might be entered by the user while editing the element or its contents. This allows a browser to
display an appropriate virtual keyboard.

It is used primarily on <input> elements, but is usable on any element in contenteditable mode.

It's important to understand that the inputmode attribute doesn't cause any validity requirements to be enforced on input. To require that input conforms to a particular data type, choose an appropriate <input> element type. For specific guidance on choosing <input> types, see the Values section.

Português: 

O atributo global inputmode é um atributo enumerado que indica o tipo de dados que pode ser
inserido pelo usuário ao editar o elemento ou seu conteúdo. Isso permite que um navegador exiba
um teclado virtual apropriado.

Ele é usado principalmente em elementos <input>, mas pode ser usado em qualquer elemento no modo contenteditable.

É importante entender que o atributo inputmode não faz com que nenhum requisito de validade seja imposto na entrada. Para exigir que a entrada esteja em conformidade com um tipo de dados específico, escolha um tipo de elemento <input> apropriado. Para obter orientações específicas sobre como escolher os tipos de <input>, consulte a seção Valores.

func (*TagTextArea) Is 

func (e *TagTextArea) Is(is string) (ref *TagTextArea)

Is

English: 

Allows you to specify that a standard HTML element should behave like a registered custom
built-in element.

Português: 

Permite especificar que um elemento HTML padrão deve se comportar como um elemento interno
personalizado registrado.

func (*TagTextArea) ItemDrop 

func (e *TagTextArea) ItemDrop(itemprop string) (ref *TagTextArea)

ItemDrop

English: 

Used to add properties to an item. Every HTML element may have an itemprop attribute specified,
where an itemprop consists of a name and value pair.

Português: 

Usado para adicionar propriedades a um item. Cada elemento HTML pode ter um atributo itemprop
especificado, onde um itemprop consiste em um par de nome e valor.

func (*TagTextArea) ItemId 

func (e *TagTextArea) ItemId(id string) (ref *TagTextArea)

ItemId

English: 

The unique, global identifier of an item.

Português: 

O identificador global exclusivo de um item.

func (*TagTextArea) ItemRef 

func (e *TagTextArea) ItemRef(itemref string) (ref *TagTextArea)

ItemRef

English: 

Properties that are not descendants of an element with the itemscope attribute can be associated
with the item using an itemref. It provides a list of element ids (not itemids) with additional
properties elsewhere in the document.

Português: 

Propriedades que não são descendentes de um elemento com o atributo itemscope podem ser
associadas ao item usando um itemref. Ele fornece uma lista de IDs de elementos (não IDs de itens)
com propriedades adicionais em outras partes do documento.

func (*TagTextArea) ItemType 

func (e *TagTextArea) ItemType(itemType string) (ref *TagTextArea)

ItemType

English: 

Specifies the URL of the vocabulary that will be used to define itemprops (item properties) in
the data structure. itemscope is used to set the scope of where in the data structure the
vocabulary set by itemtype will be active.

Português: 

Especifica a URL do vocabulário que será usado para definir itemprops (propriedades do item) na
estrutura de dados. itemscope é usado para definir o escopo de onde na estrutura de dados o
vocabulário definido por tipo de item estará ativo.

func (*TagTextArea) Lang 

func (e *TagTextArea) Lang(language Language) (ref *TagTextArea)

Lang

English: 

Specifies the language of the element's content.

The lang attribute specifies the language of the element's content.

Common examples are KLanguageEnglish for English, KLanguageSpanish for Spanish, KLanguageFrench for French, and so on.

Português: 

Especifica o idioma do conteúdo do elemento.

O atributo lang especifica o idioma do conteúdo do elemento.

Exemplos comuns são KLanguageEnglish para inglês, KLanguageSpanish para espanhol, KLanguageFrench para francês e assim por diante.

func (*TagTextArea) MaxLength 

func (e *TagTextArea) MaxLength(maxlength int) (ref *TagTextArea)

MaxLength

English: 

The maximum number of characters (UTF-16 code units) that the user can enter.

 Note:
   * If this value isn't specified, the user can enter an unlimited number of characters.

Português: 

O número máximo de caracteres (unidades de código UTF-16) que o usuário pode inserir.

 Nota:
   * Se esse valor não for especificado, o usuário poderá inserir um número ilimitado de
     caracteres.

func (*TagTextArea) MinLength 

func (e *TagTextArea) MinLength(maxlength int) (ref *TagTextArea)

MinLength

English: 

The minimum number of characters (UTF-16 code units) required that the user should enter.

Português: 

O número mínimo de caracteres (unidades de código UTF-16) que o usuário pode inserir.

func (*TagTextArea) Nonce 

func (e *TagTextArea) Nonce(part ...string) (ref *TagTextArea)

Nonce

English: 

A space-separated list of the part names of the element. Part names allows CSS to select and style
specific elements in a shadow tree via the ::part pseudo-element.

Português: 

Uma lista separada por espaços dos nomes das partes do elemento. Os nomes das partes permitem que
o CSS selecione e estilize elementos específicos em uma árvore de sombra por meio do
pseudo-elemento ::part.

func (*TagTextArea) Placeholder 

func (e *TagTextArea) Placeholder(placeholder string) (ref *TagTextArea)

Placeholder

English: 

The placeholder attribute is a string that provides a brief hint to the user as to what kind of
information is expected in the field. It should be a word or short phrase that provides a hint
as to the expected type of data, rather than an explanation or prompt. The text must not include
carriage returns or line feeds. So for example if a field is expected to capture a user's first
name, and its label is "First Name", a suitable placeholder might be "e.g. Mustafa".

 Note:
   * The placeholder attribute is not as semantically useful as other ways to explain your form,
     and can cause unexpected technical issues with your content. See Labels for more information.

Português: 

O atributo placeholder é uma string que fornece uma breve dica ao usuário sobre que tipo de
informação é esperada no campo. Deve ser uma palavra ou frase curta que forneça uma dica sobre o
tipo de dados esperado, em vez de uma explicação ou prompt. O texto não deve incluir retornos de
carro ou feeds de linha. Assim, por exemplo, se espera-se que um campo capture o primeiro nome de
um usuário e seu rótulo for "Nome", um espaço reservado adequado pode ser "por exemplo, Mustafa".

 Nota:
   * O atributo placeholder não é tão semanticamente útil quanto outras formas de explicar seu
     formulário e pode causar problemas técnicos inesperados com seu conteúdo. Consulte Rótulos
     para obter mais informações.

func (*TagTextArea) ReadOnly 

func (e *TagTextArea) ReadOnly(readonly bool) (ref *TagTextArea)

ReadOnly

English: 

A Boolean attribute which, if present, indicates that the user should not be able to edit the
value of the input.

Português: 

Um atributo booleano que, se presente, indica que o usuário não deve poder editar o valor da
entrada.

func (*TagTextArea) Required 

func (e *TagTextArea) Required(required bool) (ref *TagTextArea)

Required

English: 

A Boolean attribute indicating that an option with a non-empty string value must be selected.

Português: 

Um atributo booleano que indica que uma opção com um valor de string não vazio deve ser
selecionada.

func (*TagTextArea) Rows 

func (e *TagTextArea) Rows(rows int) (ref *TagTextArea)

Rows

English:

The number of visible text lines for the control. 

Note:
  * If it is specified, it must be a positive integer;
  * If it is not specified, the default value is 2.

Português:

O número de linhas de texto visíveis para o controle. 

Nota:
  * Se for especificado, deve ser um número inteiro positivo;
  * Se não for especificado, o valor padrão é 2.

func (*TagTextArea) SetName 

func (e *TagTextArea) SetName(name string) (ref *TagTextArea)

SetName

English: 

O nome do elemento enviado.

Português: 

O nome do elemento enviado.

func (*TagTextArea) SetX 

func (e *TagTextArea) SetX(x int) (ref *TagTextArea)

SetX

English: 

Sets the X axe in pixels.

Português: 

Define o eixo X em pixels.

func (*TagTextArea) SetXY 

func (e *TagTextArea) SetXY(x, y int) (ref *TagTextArea)

SetXY

English: 

Sets the X and Y axes in pixels.

Português: 

Define os eixos X e Y em pixels.

func (*TagTextArea) SetY 

func (e *TagTextArea) SetY(y int) (ref *TagTextArea)

SetY

English: 

Sets the Y axe in pixels.

Português: 

Define o eixo Y em pixels.

func (*TagTextArea) Slot 

func (e *TagTextArea) Slot(slot string) (ref *TagTextArea)

Slot

English: 

Assigns a slot in a shadow DOM shadow tree to an element: An element with a slot attribute is
assigned to the slot created by the <slot> element whose name attribute's value matches that slot
attribute's value.

Português: 

Atribui um slot em uma shadow DOM shadow tree a um elemento: Um elemento com um atributo slot é
atribuído ao slot criado pelo elemento <slot> cujo valor do atributo name corresponde ao valor
desse atributo slot.

func (*TagTextArea) Spellcheck 

func (e *TagTextArea) Spellcheck(spell bool) (ref *TagTextArea)

Spellcheck

English: 

Specifies whether the element is to have its spelling and grammar checked or not

 Note:
   * The following can be spellchecked:
       Text values in input elements (not password)
       Text in <textarea> elements
       Text in editable elements

Português: 

Especifica se o elemento deve ter sua ortografia e gramática verificadas ou não

O seguinte pode ser verificado ortográfico: 

Nota:
  * O seguinte pode ser verificado ortográfico:
      Valores de texto em elementos de entrada (não senha)
      Texto em elementos <textarea>
      Texto em elementos editáveis

func (*TagTextArea) Style 

func (e *TagTextArea) Style(style string) (ref *TagTextArea)

Style

English: 

Specifies an inline CSS style for an element.

The style attribute will override any style set globally, e.g. styles specified in the <style> tag or in an external style sheet.

The style attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica um estilo CSS embutido para um elemento

O atributo style substituirá qualquer conjunto de estilos globalmente, por exemplo estilos especificados na tag <style> ou em uma folha de estilo externa.

O atributo style pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagTextArea) TabIndex 

func (e *TagTextArea) TabIndex(index int) (ref *TagTextArea)

TabIndex

English: 

Specifies the tabbing order of an element (when the "tab" button is used for navigating).

The tabindex attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica a ordem de tabulação de um elemento (quando o botão "tab" é usado para navegar).

O atributo tabindex pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagTextArea) Title 

func (e *TagTextArea) Title(title string) (ref *TagTextArea)

Title

English: 

Specifies extra information about an element.

The information is most often shown as a tooltip text when the mouse moves over the element.

The title attribute can be used on any HTML element (it will validate on any HTML element. However, it is not necessarily useful).

Português: 

Especifica informações extras sobre um elemento.

As informações geralmente são mostradas como um texto de dica de ferramenta quando o mouse se move sobre o elemento.

O atributo title pode ser usado em qualquer elemento HTML (vai validar em qualquer elemento HTML. No entanto, não é necessariamente útil).

func (*TagTextArea) Translate 

func (e *TagTextArea) Translate(translate Translate) (ref *TagTextArea)

Translate

English: 

Specifies whether the content of an element should be translated or not.

 Input:
   translate: element should be translated or not. [ KTranslateYes | KTranslateNo ]

English: 

Especifica se o conteúdo de um elemento deve ser traduzido ou não.

 Entrada:
   translate: elemento deve ser traduzido ou não. [ KTranslateYes | KTranslateNo ]

func (*TagTextArea) Warp 

func (e *TagTextArea) Warp(warp Warp) (ref *TagTextArea)

Warp

English: 

Indicates how the control wraps text.

Português: 

Indica como o controle quebra o texto.

type Target 

type Target string
const (
	// KTargetSelf
	//
	// English:
	//
	//  The current browsing context; (default)
	//
	// Português:
	//
	//  O contexto de navegação atual; (padrão)
	//
	KTargetSelf Target = "_self"

	// KTargetBlank
	//
	// English:
	//
	//  Usually a new tab, but users can configure browsers to open a new window instead;
	//
	// Português:
	//
	//  Normalmente, uma nova guia, mas os usuários podem configurar os navegadores para abrir uma nova
	//  janela;
	//
	KTargetBlank Target = "_blank"

	// KTargetParent
	//
	// English:
	//
	//  The parent browsing context of the current one. If no parent, behaves as _self;
	//
	// Português:
	//
	//  O contexto de navegação pai do atual. Se nenhum pai, se comporta como _self;
	//
	KTargetParent Target = "_parent"

	// KTargetTop
	//
	// English:
	//
	//  The topmost browsing context (the "highest" context that's an ancestor of the current one).
	//  If no ancestors, behaves as _self.
	//
	// Português:
	//
	//  O contexto de navegação mais alto (o contexto "mais alto" que é um ancestral do atual).
	//  Se não houver ancestrais, se comporta como _self.
	//
	KTargetTop Target = "_top"
)

func (Target) String 

func (e Target) String() string

type TextBaseLineRule 

type TextBaseLineRule string
const (
	// KTextBaseLineRuleAlphabetic
	//
	// English:
	//
	//  (Default) The text baseline is the normal alphabetic baseline.
	//
	// Português:
	//
	//  (Padrão) A linha de base do texto é a linha de base alfabética normal.
	KTextBaseLineRuleAlphabetic TextBaseLineRule = "alphabetic"

	// KTextBaseLineRuleTop
	//
	// English:
	//
	//  The text baseline is the top of the em square.
	//
	// Português:
	//
	//  A linha de base do texto é a parte superior do quadrado em.
	KTextBaseLineRuleTop TextBaseLineRule = "top"

	// KTextBaseLineRuleHanging
	//
	// English:
	//
	//  The text baseline is the hanging baseline.
	//
	// Português:
	//
	//  A linha de base do texto é a linha de base suspensa.
	KTextBaseLineRuleHanging TextBaseLineRule = "hanging"

	// KTextBaseLineRuleMiddle
	//
	// English:
	//
	//  The text baseline is the middle of the em square.
	//
	// Português:
	//
	//  A linha de base do texto é o meio do quadrado em.
	KTextBaseLineRuleMiddle TextBaseLineRule = "middle"

	// KTextBaseLineRuleIdeographic
	//
	// English:
	//
	//  The text baseline is the ideographic baseline.
	//
	// Português:
	//
	//  The text baseline is the ideographic baseline.
	KTextBaseLineRuleIdeographic TextBaseLineRule = "ideographic"

	// KTextBaseLineRuleBottom
	//
	// English:
	//
	//  The text baseline is the bottom of the bounding box.
	//
	// Português:
	//
	//  A linha de base do texto é a parte inferior da caixa delimitadora.
	KTextBaseLineRuleBottom TextBaseLineRule = "bottom"
)

func (TextBaseLineRule) String 

func (e TextBaseLineRule) String() string

type Translate 

type Translate string
const (
	// KTranslateYes
	//
	// English:
	//
	//  The translate attribute specifies whether the content of an element should be translated.
	//
	// Português:
	//
	//  O atributo translate especifica se o conteúdo de um elemento deve ser traduzido.
	KTranslateYes Translate = "yes"

	// KTranslateNo
	//
	// English:
	//
	//  The translate attribute specifies whether the content of an element should not be translated.
	//
	// Português:
	//
	//  O atributo translate especifica se o conteúdo de um elemento não deve ser traduzido.
	KTranslateNo Translate = "no"
)

func (Translate) String 

func (e Translate) String() (element string)

type Warp 

type Warp string
const (
	// KWarpHard
	//
	// English:
	//
	//  The browser automatically inserts line breaks (CR+LF) so that each line has no more than the
	//  width of the control;
	//
	//   Note:
	//     * The cols attribute must also be specified for this to take effect.
	//
	// Português:
	//
	//  O navegador insere automaticamente quebras de linha (CR+LF) para que cada linha não tenha mais
	//  que a largura do controle;
	//
	//   Nota:
	//     * O atributo cols também deve ser especificado para que tenha efeito.
	KWarpHard Warp = "hard"

	// KWarpSoft
	//
	// English:
	//
	//  The browser ensures that all line breaks in the value consist of a CR+LF pair, but does not
	//  insert any additional line breaks.
	//
	// Português:
	//
	//  O navegador garante que todas as quebras de linha no valor consistam em um par CR+LF, mas não
	//  insere nenhuma quebra de linha adicional.
	KWarpSoft Warp = "soft"

	// KWarpOff
	//
	// English:
	//
	//  Like soft but changes appearance to white-space: pre so line segments exceeding cols are not
	//  wrapped and the <textarea> becomes horizontally scrollable.
	//
	//   Note:
	//     * Non-Standard
	//
	// Português:
	//
	//  Como soft, mas altera a aparência para espaço em branco: antes disso, os segmentos de linha que
	//  excedem as colunas não são quebrados e a <textarea> torna-se rolável horizontalmente.
	//
	//   Nota:
	//     * Não-Padrão
	KWarpOff Warp = "off"
)

func (Warp) String 

func (e Warp) String() string

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.