# Editory a API pro MJML

> Vytvářejte responzivní šablony a kampaně v MJML, alfaverzi otevřené jen týmu Emailitu. Vizuální editor a editor kódu, uložené dokumenty, validace, Temple v MJML, živá spolupráce a API pro MJML.

[MJML](https://mjml.io) je značkovací jazyk pro responzivní e-maily. Píšete sekce, sloupce a komponenty, například `<mj-text>` a `<mj-button>`, a MJML je zkompiluje do HTML, které se v různých e-mailových klientech vykreslí stejně. V Emailitu může být MJML zdrojem šablony nebo kampaně: napíšete ho v editorech ve webovém rozhraní, nebo ho pošlete přes API, a Emailit ho zvaliduje a zkompiluje z něj HTML.

> **MJML je v alfaverzi:** MJML je v alfaverzi a dokud ho testujeme, je otevřené jen týmu Emailitu. Workspace zákazníků editory MJML zatím nevidí a požadavky API, které vytvářejí nebo mění šablony MJML nebo volají endpointy MJML, vracejí `403` s `error: "mjml_alpha"`. Tato stránka popisuje, jak MJML funguje, abyste s ním mohli počítat. Šablony a kampaně vytvořené v MJML může i tak odesílat kdokoli.

## Přehled

- **Šablony**: `editor: "mjml"` a MJML v `source`. Viz [Vytvoření šablony](/cs/docs/api-reference/templates/create/).
- **Kampaně**: `content_type: "mjml"` a MJML v `content`. Viz [Kampaně](#campaigns).
- **Automatizace**: krok **Send email** odešle šablonu MJML stejně jako kteroukoli jinou šablonu. Viz [Automatizace](#automations).
- **Endpointy MJML**: [Validace MJML](/cs/docs/api-reference/mjml/validate/), [Vykreslení MJML](/cs/docs/api-reference/mjml/render/) a [Načtení reference MJML](/cs/docs/api-reference/mjml/reference/).

### Kdo může MJML používat

Během alfaverze je MJML dostupné jen administrátorům platformy Emailit. Role **Admin** ve workspace nestačí.

| Kde | Tým Emailitu | Všichni ostatní |
| --- | --- | --- |
| Webové rozhraní | Editory MJML, import MJML, **Edit with AI** a živá spolupráce | Žádné editory MJML. Šablona nebo kampaň MJML zobrazí poznámku, nejde otevřít v editoru a i tak se odešle. |
| API | Šablony MJML, kampaně MJML a endpointy MJML | `403` s `error: "mjml_alpha"`. U kampaně zůstává `content_type: "mjml"` pouhým označením, stejně jako před alfaverzí. Viz [Kampaně](#campaigns). |
| API klíče | Žádné. API klíče patří workspace, ne konkrétnímu člověku. | `403` s `error: "mjml_alpha"` |
| MCP server | Nástroje MJML a parametry MJML v nástrojích pro šablony a kampaně | Nezobrazují se |

Přejmenovat, publikovat, vyexportovat, odeslat a smazat šablony a kampaně MJML může i nadále kdokoli. Duplikací šablony MJML vznikne nová šablona MJML, takže k ní potřebujete přístup k MJML.

### Verze MJML

Emailit kompiluje veškeré MJML pomocí **MJML 5.4.1**, na serveru i v živém náhledu v editorech. Validace kontroluje tagy, atributy a hodnoty atributů podle této verze. Endpoint [Načtení reference MJML](/cs/docs/api-reference/mjml/reference/) vrací tuto verzi a všechny komponenty a atributy, které podporuje.

### Editory

Webové rozhraní má dva editory MJML. Oba mají vlastní verze a oba jsou alfaverze `0.x`.

| Editor | ID | Verze | Popis |
| --- | --- | --- | --- |
| MJML Visual Editor | `mjml-visual` | 0.2.0 (alfaverze) | Drag & drop přímo na vykresleném e-mailu, pokrývá všechny komponenty a atributy MJML |
| MJML Code Editor | `mjml-code` | 0.2.0 (alfaverze) | MJML s automatickým doplňováním, průběžnou validací a živým náhledem pro počítač i mobil |

Oba editory ukládají šablonu s `editor: "mjml"`. Uložený dokument zaznamenává, který editor a v jaké verzi ho naposledy uložil. Kolegové mohou stejnou šablonu nebo kampaň upravovat současně. Viz [Společné úpravy](#editing-together).

## Formáty zdroje

Všude, kde Emailit přijímá MJML (pole `source` u šablony, `content` u kampaně a pole `source` u endpointů MJML), můžete poslat kterýkoli z těchto formátů:

| Formát | Příklad |
| --- | --- |
| Značkování MJML | Řetězec, který začíná `<mjml>`. Před ním smí být deklarace XML nebo komentáře. |
| MJML JSON | Vlastní formát JSON jazyka MJML, jako objekt nebo řetězec JSON: `{ "tagName": "mjml", "attributes": {}, "children": [ … ] }`. Komponenty typu ending tag, například `mj-text`, mají své HTML v `content`. |
| Dokument MJML Emailitu | Obálka, kterou Emailit ukládá (viz níže), jako objekt nebo řetězec JSON |

Cokoli jiného Emailit odmítne s kódem `document.unrecognized`. Zdroje větší než 2 MB odmítne s kódem `document.too-large`.

### Uložený dokument

Emailit ukládá MJML do obálky s verzí. Je to `source` šablony a `content` kampaně:

```json
{
  "kind": "emailit/mjml",
  "schema_version": 1,
  "mjml_version": "5.4.1",
  "editor": "api",
  "editor_version": null,
  "format": "markup",
  "content": "<mjml>\n  <mj-body>\n    …\n  </mj-body>\n</mjml>"
}
```

| Pole | Popis |
| --- | --- |
| `kind` | Vždy `emailit/mjml`. |
| `schema_version` | Verze tvaru obálky. Aktuálně `1`. |
| `mjml_version` | Vydání MJML, pro které je obsah určený. Emailit sem zapíše verzi, se kterou kompiloval. |
| `editor` | Co dokument naposledy zapsalo: `mjml-visual`, `mjml-code`, `ai` (**Edit with AI**) nebo `api` (API, nástroje MCP a import souborů). |
| `editor_version` | Verze tohoto editoru, nebo `null`. |
| `format` | `markup`: `content` je značkování MJML uložené tak, jak je napsané, včetně komentářů a formátování. `json`: `content` je MJML JSON. |
| `content` | Samotné MJML. |

Formát určuje to, co pošlete: značkování se uloží jako `markup` a MJML JSON jako `json`. Obojí se zaznamená jako `editor: "api"`. Obálka, kterou pošlete, si ponechá svůj `editor` a `editor_version`.

Odpovědi API vracejí `source` jako tuto obálku převedenou na řetězec JSON a můžete ji poslat zpět beze změny. Odpovědi také obsahují objekt `mjml` s verzemi obálky:

```json
"mjml": {
  "mjml_version": "5.4.1",
  "schema_version": 1,
  "editor": "api",
  "editor_version": null,
  "format": "markup"
}
```

Webové rozhraní otevře dokument v editoru, který ho naposledy uložil. Dokumenty zapsané přes API se otevřou v editoru kódu, když má `format` hodnotu `markup`, a ve vizuálním editoru, když má hodnotu `json`.

## Kompilace a uložení

U šablon a kampaní MJML spravuje HTML Emailit:

- Při vytvoření a úpravě Emailit MJML zvaliduje a zkompiluje. Zkompilované HTML se uloží jako `html` šablony a jakékoli `html`, které pošlete, se ignoruje.
- Při odesílání se použije uložené HTML. Značky Temple v něm zůstávají a vykreslí se pro každého příjemce při odeslání.
- Když upravíte jen jiná pole, například `name` nebo `subject`, MJML se znovu nekompiluje.
- `text` se z MJML negeneruje. Pokud chcete část v prostém textu, pošlete `text` sami.
- Když existující šablonu přepnete na `editor: "mjml"` a nepošlete `source`, zkompiluje se uložený `source` šablony, který pak musí být MJML.

HTML se kompiluje při uložení, takže HTML existující šablony se změní, až když ji znovu uložíte.

```bash
curl https://api.emailit.com/v2/templates \
  -H "Authorization: Bearer your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Welcome",
    "alias": "welcome",
    "subject": "Welcome, {{first_name|\"there\"}}",
    "editor": "mjml",
    "source": "<mjml><mj-head><mj-title>Welcome</mj-title><mj-preview>Your account is ready</mj-preview></mj-head><mj-body><mj-section><mj-column><mj-text>Hi {{first_name|\"there\"}}, welcome aboard.</mj-text><mj-button href=\"{{activation_url}}\">Activate account</mj-button></mj-column></mj-section></mj-body></mjml>"
  }'
```

Pak ji odešlete jako kteroukoli jinou šablonu endpointem [Odeslání e-mailu](/cs/docs/api-reference/emails/send/): s `"template": "welcome"` a objektem `variables`.

## Validace

Každé uložení provede stejné kontroly jako [Validace MJML](/cs/docs/api-reference/mjml/validate/):

- Syntaxe XML: neuzavřené nebo nepárové tagy a poškozené atributy (`xml.*`)
- Struktura MJML, atributy a hodnoty atributů pro MJML 5.4.1 (`mjml.*`)
- Syntaxe Temple a spárované bloky `{{#if}}` (`temple.*`)
- Formát zdroje a verze (`document.*`) a samotný kompilátor (`compiler.*`)

Každé zjištění je diagnostické hlášení se závažností:

| Závažnost | Co se stane |
| --- | --- |
| `error` | MJML se odmítne. Šablony a kampaně se neuloží. |
| `warning` | Uloží se. Pravděpodobně jde o chybu: chybí `<mj-title>`, text je mimo komponentu, podmíněný blok přesahuje přes více komponent nebo HTML překračuje limit 102 KB, nad kterým ho Gmail ořízne. |
| `info` | Uloží se. Návrh nebo poznámka: chybí `<mj-preview>`, obrázek nemá `alt` nebo je dokument napsaný pro starší verzi MJML. |

Hlášení má tato pole. Pole, která se ho netýkají, se vynechávají.

| Pole | Popis |
| --- | --- |
| `severity` | `error`, `warning` nebo `info` |
| `code` | Stálý strojově čitelný kód, například `mjml.invalid-child` |
| `message` | Čitelné vysvětlení, často s opravou („Did you mean color?“) |
| `line`, `column` | Pozice ve značkování, číslovaná od 1. Jen u zdrojů ve značkování. |
| `tag` | Prvek, kterého se hlášení týká |
| `attribute` | Atribut, pokud nějaký je |
| `path` | Cesta indexů potomků od kořene `<mjml>`. `[0, 1]` je druhý potomek prvního potomka. |

### Chybová odpověď

Uložení šablony nebo kampaně s chybovými hlášeními vrací `422`. Pro tento zdroj:

```xml
<mjml>
  <mj-body>
    <mj-section>
      <mj-column>
        <mj-text colour="#333333">Hi {{first_name|"there"}}</mj-text>
        <mj-button href="{{cta_url}}">{{#if trial}}Start trial</mj-button>
      </mj-column>
    </mj-section>
  </mj-body>
</mjml>
```

vypadá odpověď takto:

```json
{
  "message": "The MJML is not valid.",
  "errors": {
    "source": [
      "Line 5: <mj-text> has no attribute colour. Did you mean color?",
      "Line 6: {{#if trial}} is never closed with {{/if}}."
    ]
  },
  "diagnostics": [
    {
      "severity": "error",
      "code": "mjml.unknown-attribute",
      "message": "<mj-text> has no attribute colour. Did you mean color?",
      "line": 5,
      "column": 18,
      "tag": "mj-text",
      "attribute": "colour",
      "path": [0, 0, 0, 0]
    },
    {
      "severity": "warning",
      "code": "mjml.missing-title",
      "message": "Add an <mj-title> to <mj-head>; clients and screen readers use it.",
      "line": 1,
      "column": 2,
      "tag": "mjml",
      "path": []
    },
    {
      "severity": "info",
      "code": "mjml.missing-preview",
      "message": "Add an <mj-preview> to control the inbox preview text.",
      "line": 1,
      "column": 2,
      "tag": "mjml",
      "path": []
    },
    {
      "severity": "error",
      "code": "temple.unclosed-if",
      "message": "{{#if trial}} is never closed with {{/if}}.",
      "line": 6,
      "column": 39,
      "tag": "mj-button",
      "path": [0, 0, 0, 1]
    }
  ]
}
```

- `errors.source` (u kampaní `errors.content`) uvádí nejvýše pět chybových zpráv, a pokud je řádek známý, i s ním.
- `diagnostics` uvádí všechna hlášení včetně varování a informací.
- Chybějící nebo prázdný zdroj vrací `422` s `"message": "Validation failed"`, `"errors": { "source": ["The source field is required for MJML."] }` a prázdným polem `diagnostics`.

[Validace MJML](/cs/docs/api-reference/mjml/validate/) provede stejné kontroly bez uložení a místo `422` vrací `200` s `valid: false`.

### Kódy hlášení

**XML** (zdroje ve značkování)

| Kód | Závažnost | Význam |
| --- | --- | --- |
| `xml.unclosed-tag` | error | Prvek se nikde neuzavírá. |
| `xml.unexpected-closing-tag` | error | Uzavírací tag neodpovídá žádnému otevřenému prvku. |
| `xml.malformed-closing-tag` | error | Uzavírací tag nejde přečíst. |
| `xml.unterminated-tag` | error | Otevírací tag nemá uzavírací `>`. |
| `xml.unterminated-attribute` | error | Hodnota atributu nemá uzavírací uvozovku. |
| `xml.missing-attribute-value` | error | `name=` nemá hodnotu. |
| `xml.invalid-attribute` | error | Neočekávaný znak uvnitř tagu. |
| `xml.duplicate-attribute` | error | Stejný atribut dvakrát u jednoho prvku. Použije se první. |
| `xml.unterminated-comment` | error | Komentář nemá `-->`. |
| `xml.unterminated-cdata` | error | Sekce CDATA nemá `]]>`. |
| `xml.unexpected-character` | error | Samostatné `<` mimo komponentu typu ending tag. |
| `xml.multiple-roots` | error | Víc než jeden kořenový prvek. |
| `xml.text-outside-root` | error | Text mimo `<mjml>`. |
| `mjml.missing-root` | error | Dokument je prázdný. |
| `xml.unquoted-attribute` | warning | Hodnota atributu bez uvozovek. |
| `xml.stray-text` | warning | Text mezi prvky mimo jakoukoli obsahovou komponentu. MJML ho ignoruje. |
| `xml.unexpected-declaration` | warning | Deklarace až po začátku `<mjml>`. |

**MJML**

| Kód | Závažnost | Význam |
| --- | --- | --- |
| `mjml.unknown-tag` | error | Prvek, který v MJML 5.4.1 neexistuje. Pokud je některý podobný, hlášení navrhne opravu („did you mean“). |
| `mjml.unknown-attribute` | error | Prvek takový atribut nemá. U samotného `<mjml>` jde o varování. |
| `mjml.invalid-attribute-value` | error | Nesprávný druh hodnoty: není to barva, jednotka ani povolená hodnota. |
| `mjml.invalid-child` | error | Prvek nesmí být uvnitř svého rodiče. |
| `mjml.invalid-root` | error | Kořenový prvek není `<mjml>`. |
| `mjml.missing-body` | error | Chybí `<mj-body>`. |
| `mjml.duplicate-body` | error | Víc než jeden `<mj-body>`. |
| `mjml.include-not-supported` | error | `<mj-include>` se nepodporuje. |
| `mjml.missing-attribute` | error nebo warning | Chybí povinný atribut. Chyba u `name` a `href` v `<mj-font>`, `name` v `<mj-class>`, `path` v `<mj-selector>` a `name` v `<mj-html-attribute>`. Varování u `src` obrázku a `width` v `<mj-breakpoint>`. |
| `mjml.missing-title` | warning | V `<mj-head>` chybí `<mj-title>`. |
| `mjml.empty-title` | warning | `<mj-title>` je prázdný. |
| `mjml.duplicate-head` | warning | Víc než jeden `<mj-head>`. |
| `mjml.ignored-content` | warning | Text uvnitř prvku, který obsah nepřijímá. |
| `mjml.ignored-children` | warning | Podřízené prvky uvnitř prvku, který přijímá jen obsah. |
| `mjml.column-widths` | warning | Šířky sloupců v sekci nebo skupině dávají dohromady víc než 100 %. |
| `mjml.unknown-social-network` | warning | Název `<mj-social-element>` bez vestavěné ikony a bez `src`. |
| `mjml.script` | warning | `<script>` v obsahu. E-mailoví klienti ho odstraní. |
| `mjml.missing-preview` | info | Chybí `<mj-preview>`. |
| `mjml.missing-alt` | info | `<mj-image>` bez `alt`. |
| `mjml.button-without-link` | info | `<mj-button>` bez `href`. |

**Temple**

| Kód | Závažnost | Význam |
| --- | --- | --- |
| `temple.unclosed-if` | error | `{{#if}}` bez `{{/if}}`. |
| `temple.endif-without-if` | error | `{{/if}}` bez `{{#if}}`. |
| `temple.else-without-if` | error | `{{else}}` mimo blok. |
| `temple.duplicate-else` | error | Dvě `{{else}}` v jednom bloku. |
| `temple.unclosed-expression` | error | `{{` bez `}}`. |
| `temple.empty-expression` | error | `{{ }}`. |
| `temple.empty-condition` | error | `{{#if}}` bez proměnné. |
| `temple.malformed-else` | error | `{{else}}` zapsané s mezerami nebo argumenty. |
| `temple.unsupported-block` | error | Jiný blok než `{{#if}}`, například `{{#each}}`. |
| `temple.unsupported-syntax` | error | Trojité závorky `{{{…}}}`, dílčí šablony `{{> …}}` nebo komentáře `{{! …}}`. |
| `temple.invalid-variable` | warning | Proměnná, která není platnou cestou. |
| `temple.invalid-condition` | warning | Podmínka, která není cestou k proměnné. Porovnání se nepodporují. |
| `temple.block-crosses-components` | warning | Blok, který se otevírá v jedné komponentě a zavírá v jiné. |

**Dokument a kompilátor**

| Kód | Závažnost | Význam |
| --- | --- | --- |
| `document.empty` | error | Zdroj je prázdný. |
| `document.unrecognized` | error | Není to značkování MJML, MJML JSON ani dokument MJML Emailitu. |
| `document.invalid-json` | error | Zdroj vypadá jako JSON, ale nejde zpracovat. |
| `document.invalid-node` | error | MJML JSON s poškozeným uzlem. |
| `document.too-large` | error | Zdroj je větší než 2 MB. |
| `document.unsupported-schema` | error | `schema_version` obálky je novější, než Emailit umí číst. |
| `document.unsupported-mjml-version` | error | Verzi MJML dokumentu nejde zkompilovat. Viz [Verze a aktualizace](#versions-and-upgrades). |
| `document.assumed-mjml-version` | info | Obálka nemá `mjml_version`, takže se předpokládá aktuální verze. |
| `document.mjml-upgraded` | info | Dokument je napsaný pro jinou verzi MJML a zkompiloval se s 5.4.1. |
| `compiler.failed` | error | MJML nedokázalo dokument vykreslit. |
| `compiler.gmail-clipping` | warning | HTML je větší než 102 KB, takže ho Gmail ořízne. |

## Temple v MJML

Značky [Temple](/cs/docs/templates/temple/) projdou kompilací MJML beze změny. Emailit je vykreslí pro každého příjemce při odeslání, a to ve zkompilovaném HTML.

### Proměnné v obsahu a atributech

Proměnné fungují v obsahu i v jakémkoli atributu:

```xml
<mj-text>Hi {{first_name|"there"}},</mj-text>
<mj-button href="{{activation_url}}">Activate your account</mj-button>
<mj-image src="{{logo_url}}" alt="{{company|'Acme'}}" />
<mj-section background-color="{{brand_color|'#ffffff'}}">
```

- Uvnitř atributu pište výchozí hodnoty v jednoduchých uvozovkách: `href="{{url|'https://example.com'}}"`.
- U hodnot atributů, které obsahují Temple, se typ nekontroluje, protože hodnota je známá až při odeslání. Zajistěte, aby proměnná obsahovala hodnotu platnou pro daný atribut, například barvu pro `background-color`.
- Hodnoty se vkládají tak, jak jsou, bez escapování HTML.

### Podmíněné bloky

V rámci jedné komponenty dejte blok do jejího obsahu:

```xml
<mj-text>{{#if plan}}You are on the {{plan}} plan.{{else}}You are on the free plan.{{/if}}</mj-text>
```

Pokud chcete zobrazit nebo skrýt celé komponenty, dejte značky bloku do sourozeneckých prvků `<mj-raw>`:

```xml
<mj-raw>{{#if vip}}</mj-raw>
<mj-section background-color="#fef3c7">
  <mj-column>
    <mj-text>Your VIP perks are ready.</mj-text>
  </mj-column>
</mj-section>
<mj-raw>{{/if}}</mj-raw>
```

Samostatné značky bloků mezi komponentami se při zpracování značkování převedou na `<mj-raw>`, takže tohle je totéž:

```xml
{{#if vip}}
<mj-section background-color="#fef3c7">
  …
</mj-section>
{{/if}}
```

Ostatní text mezi komponentami MJML ignoruje a validace ho hlásí jako `xml.stray-text`.

- Bloky musí být spárované v celém dokumentu. Neuzavřená nebo přebytečná značka je chyba.
- Každý blok otevřete i uzavřete v obsahu jedné komponenty, nebo mezi sourozeneckými prvky `<mj-raw>` jednoho rodiče. Blok, který se otevírá v jedné komponentě a zavírá v jiné, dostane varování `temple.block-crosses-components`, protože jeho skrytí by rozdělilo strukturu HTML.
- Bloky lze vnořovat.

### Co se nepodporuje

- `<mj-include>` se odmítne s kódem `mjml.include-not-supported`. Vložené MJML zkopírujte přímo do dokumentu.
- Tagy a atributy, které MJML 5.4.1 nedefinuje, jsou chyby.
- Temple nemá cykly, pomocné funkce, dílčí šablony, komentáře, trojité závorky ani porovnání. Viz [Temple](/cs/docs/templates/temple/).

### Proměnné podle kanálu

Stejnou šablonu MJML lze odeslat z několika míst a každé z nich poskytuje jiné proměnné:

| Odesláno z | Proměnné |
| --- | --- |
| Endpoint API [Odeslání e-mailu](/cs/docs/api-reference/emails/send/) s `template` | Objekt `variables`, který předáte |
| Krok automatizace **Send email** | Automatizace kontaktů: pole kontaktu na nejvyšší úrovni (`{{first_name}}`, `{{email}}`), vlastní pole jako `{{cf.<key>}}` nebo `{{custom_fields.<key>}}` a navíc `{{contact.*}}`, `{{payload.*}}` a `{{meta.*}}` |
| Kampaně MJML | `{{first_name}}`, `{{last_name}}`, `{{email}}`, `{{unsubscribe_url}}`, `{{cf.<key>}}` a stejná pole pod `{{contact.*}}` |

Editory vkládají vlastní pole jako `{{cf.<key>}}`, což funguje v kampaních MJML i v automatizacích. Při odesílání přes API předejte proměnné sami.

Verzi pro konkrétního příjemce si zobrazíte, když zavoláte [Vykreslení MJML](/cs/docs/api-reference/mjml/render/) s `variables`.

## Kampaně

Kampaň s `content_type: "mjml"` ukládá své MJML do `content` v kterémkoli z [formátů zdroje](#source-formats) a Emailit z něj zkompiluje její `html`. Stejně jako u šablon se jakékoli `html`, které pošlete, ignoruje. Neplatné MJML vrací `422` s `errors.content` a `diagnostics`. Když pošlete prázdný `content`, smaže se obsah i HTML. Odpovědi pro kampaně obsahují stejný objekt `mjml` jako šablony.

Kampaně MJML vykreslují předmět, HTML a text jazykem **Temple** pro každého příjemce, a to i u testovacích e-mailů. K dispozici jsou tyto proměnné:

| Proměnná | Hodnota |
| --- | --- |
| `{{first_name}}` | Křestní jméno kontaktu |
| `{{last_name}}` | Příjmení kontaktu |
| `{{email}}` | E-mailová adresa kontaktu |
| `{{unsubscribe_url}}` | Odkaz pro odhlášení pro tento kontakt a kampaň |
| `{{cf.<key>}}` | Vlastní pole kontaktu, například `{{cf.company}}` |
| `{{contact.first_name}}`, `{{contact.cf.<key>}}`, … | Stejná pole pod `contact` |

Prázdná pole kontaktu se počítají jako chybějící, takže se použijí výchozí hodnoty: `{{first_name|"there"}}` vykreslí u kontaktu bez křestního jména `there`. V patičce marketingových e-mailů ponechte odkaz `{{unsubscribe_url}}`.

Klasické kampaně (HTML, text a ostatní editory) dál používají pevné slučovací značky:

| | Klasické kampaně | Kampaně MJML |
| --- | --- | --- |
| Mechanismus | Pevné slučovací značky | Temple |
| `{{#if}}` … `{{else}}` … `{{/if}}` | Nezpracovává se | Podporováno |
| Výchozí hodnoty, například `{{first_name\|"there"}}` | Nezpracovávají se | Podporovány. Prázdná pole se počítají jako chybějící. |
| Velikost písmen | `{{FIRST_NAME}}` funguje | Cesty rozlišují velká a malá písmena |
| Neznámé značky | Zůstanou ve zprávě tak, jak jsou napsané | Vykreslí se jako prázdné |

Když ve webovém rozhraní založíte kampaň ze šablony MJML, zkopíruje se dokument MJML šablony do kampaně.

### Bez přístupu k MJML

Během alfaverze Emailit kompiluje MJML kampaní jen pro tým Emailitu. Pro všechny ostatní, včetně API klíčů, zůstává `content_type: "mjml"` pouhým označením jako před alfaverzí: `content` se uloží tak, jak ho pošlete, zkompilované HTML posíláte v `html` a při odesílání se použijí klasické slučovací značky. Když kampaň založíte ze šablony MJML, zkopíruje se HTML šablony do kampaně typu HTML.

## Automatizace

Krok **Send email** odkazuje na šablonu podle ID (`tem_…`). Šablony MJML fungují jako kterékoli jiné: krok odešle zkompilované HTML šablony a vykreslí Temple s proměnnými automatizace. Viz [E-maily z automatizací](/cs/docs/templates/temple/#automation-emails).

V nastavení kroku tlačítko **Design a new email** vytvoří šablonu MJML z úvodního designu, vybere ji pro krok a otevře ji ve vizuálním editoru. Tlačítko **Edit email** otevře vybranou šablonu MJML. Úpravy mění samotnou šablonu, takže se projeví v každém kroku a volání API, které tuto šablonu používá. Bez přístupu k MJML krok místo toho zobrazí odkaz na šablonu.

## Společné úpravy

Každý, kdo otevře stejnou uloženou šablonu nebo kampaň MJML, upravuje v reálném čase jeden sdílený koncept, a to v kterémkoli z obou editorů:

- **Přítomnost**: záhlaví ukazuje, kdo další upravuje a co právě dělá. Ve vizuálním editoru vidíte jejich výběry, kurzory a krátké zvýraznění v jejich barvě tam, kde něco mění. Panel **Layers** ukazuje, kdo má kterou komponentu vybranou. Výběrem avataru přeskočíte na výběr daného člověka.
- **Úpravy se slučují**: změny různých komponent, atributů nebo částí textu se spojí, místo aby se navzájem přepsaly. Zatímco někdo píše do textu na plátně, je tento text pro ostatní zamčený.
- **Editor kódu**: vaše změny se do sdíleného konceptu slučují průběžně, jak píšete. Změny ostatních se ve vašem kódu objeví, až přestanete psát, aby vám neposkakoval kurzor. Pokud má váš kód syntaktickou chybu, počkají, dokud ji neopravíte.
- **Zpět a znovu** vracejí jen vaše vlastní změny.
- **Ukládání**: pro všechny je jedno tlačítko **Save**. Záhlaví ukazuje neuložené změny celého konceptu a kdo naposledy ukládal. Odesílá se vždy uložená verze.
- **Koncept zůstává**: zavřením editoru ani výpadkem připojení o změny nepřijdete. Zůstanou ve sdíleném konceptu a synchronizují se, až budete znovu online. Po opětovném otevření editoru se neuložené změny obnoví a můžete je zahodit a vrátit se k uložené verzi.
- **Uloženo jinde**: když se šablona nebo kampaň uloží mimo editor (přes API, MCP nebo **Edit with AI**), zatímco je otevřená, koncept bez neuložených změn se přepne na uloženou verzi. Koncept s neuloženými změnami si je ponechá a nabídne **Load saved version**, nebo **Keep this draft**.
- **Smazáno**: pokud se šablona nebo kampaň během úprav smaže nebo přestane být MJML, editor vás na to upozorní a nechá vás MJML zkopírovat.

Společné úpravy vyžadují uložené a platné MJML. Šablona nebo kampaň, jejíž MJML nejde zpracovat, nebo která ještě není uložená jako MJML, se otevře bez nich: každý upravuje sám a platí poslední uložení. Editor na to upozorní v banneru. V zablokovaném workspace jsou editory jen pro čtení.

## Verze a aktualizace

Emailit kompiluje vždy jednou verzí MJML, aktuálně 5.4.1. Každý uložený dokument zaznamenává `mjml_version`, pro kterou je určený, a Emailit ji kontroluje při každé kompilaci dokumentu:

| `mjml_version` dokumentu | Výsledek |
| --- | --- |
| 5.4.1 | Zkompiluje se tak, jak je |
| Chybí | Předpokládá se 5.4.1 (`document.assumed-mjml-version`, info) |
| Jiné vydání 5.x | Zkompiluje se s 5.4.1 (`document.mjml-upgraded`, info) |
| 4.x | Převede se na MJML 5 a pak se zkompiluje s 5.4.1 (`document.mjml-upgraded`, info). MJML 4 a 5 mají stejné komponenty a atributy; výstupní HTML se mírně liší. |
| 3.x nebo starší | Odmítne se s `document.unsupported-mjml-version` |
| Novější hlavní verze | Odmítne se s `document.unsupported-mjml-version` |

Dokument, jehož `schema_version` je novější, než Emailit umí číst, se odmítne s `document.unsupported-schema`. Při uložení se dokument uloží s aktuální `mjml_version` a `schema_version`. Po aktualizaci zkontrolujte náhled.

Editory zobrazují svou verzi a přehled změn. Když byl dokument uložen novější verzí editoru, než jakou má stránka, kterou máte otevřenou, editor vás požádá o její obnovení.

## MJML pro AI agenty

[Načtení reference MJML](/cs/docs/api-reference/mjml/reference/) dává nástrojům a AI modelům vše, co potřebují k psaní platného MJML pro Emailit: každou komponentu s povolenými rodiči, potomky a atributy (typ a výchozí hodnota), průvodce jazykem Temple, pravidla pro psaní MJML a kompaktní `reference_text` v prostém textu pro prompty.

Na [MCP serveru](/cs/docs/mcp/) dostávají relace týmu Emailitu v sadě nástrojů `templates` navíc tyto nástroje:

| Nástroj | Popis |
| --- | --- |
| `get-mjml-reference` | Reference jako text: verze MJML a editorů, pravidla pro psaní, průvodce jazykem Temple a reference komponent. |
| `validate-mjml` | [Validace MJML](/cs/docs/api-reference/mjml/validate/): `valid` a diagnostická hlášení. |
| `render-mjml` | [Vykreslení MJML](/cs/docs/api-reference/mjml/render/): zkompilované HTML a s `variables` také `rendered_html`. |
| `create-template`, `update-template` | Přijímají také `editor: "mjml"` a `source`, tedy značkování MJML nebo MJML JSON jako řetězec. HTML zkompiluje Emailit. |
| `create-campaign`, `update-campaign` | Přijímají také `content_type: "mjml"` s MJML v `content`. |

Když uložení neprojde validací, chyba nástroje uvede chybová hlášení a varování s čísly řádků, aby agent mohl zdroj opravit. Typický postup: přečíst referenci, napsat MJML, volat `validate-mjml`, dokud `valid` není `true`, uložit pomocí `create-template` a pak zkontrolovat verzi pro příjemce pomocí `render-mjml`. Ostatní relace tyto nástroje ani parametry nevidí.

## Ve webovém rozhraní

- **Šablony**: vytvořte šablonu a zvolte **MJML Visual Editor (Alpha)**, nebo **MJML Code Editor (Alpha)**.
- **Vizuální editor**: drag & drop přímo na vykresleném e-mailu, strom vrstev, panel vlastností pro každý atribut MJML, nastavení dokumentu (hlavička, písma, styly a výchozí atributy), proměnné Temple v jakékoli vlastnosti a podmíněné bloky kolem komponent.
- **Editor kódu**: automatické doplňování tagů, atributů a hodnot MJML i jazyka Temple, průběžná validace s rychlými opravami a formátování.
- **Oba editory**: živý náhled pro počítač i mobil kompilovaný v prohlížeči pomocí MJML 5.4.1, náhled s ukázkovými daty (s vykresleným Temple), seznam problémů a AI asistent, pokud je zapnutý. U stejného dokumentu můžete přepínat mezi vizuálním editorem a editorem kódu; přepnutí do vizuálního editoru vyžaduje kód bez syntaktických chyb. Dokud MJML obsahuje chyby, nejde ho uložit.
- **Společné úpravy**: kolegové, kteří otevřou stejnou šablonu nebo kampaň, ji upravují v reálném čase. Viz [Společné úpravy](#editing-together).
- **Edit with AI**: popište změnu šablony nebo kampaně MJML, aniž byste otevírali editor.
- **Import**: soubor `.mjml`, soubor `.json` s MJML JSON nebo dokumentem MJML Emailitu, nebo ZIP s `template.mjml` a složkou `images/` v kořeni.
- **Export**: MJML (značkování), MJML JSON (uložený dokument), HTML, nebo ZIP s `template.mjml`, `template.html` a `images/`. Export funguje pro všechny.
- **Kampaně**: pro obsah kampaně zvolte MJML Visual Editor, nebo MJML Code Editor.
- **Automatizace**: e-mail kroku **Send email** navrhnete přímo na místě. Viz [Automatizace](#automations).

## Související

- [Vytváření a úprava šablon](/cs/docs/templates/editors/)
- [Šablonovací jazyk Temple](/cs/docs/templates/temple/)
- [Reference API pro MJML](/cs/docs/api-reference/mjml/)
- [Import a export šablon](/cs/docs/templates/import-export/)

---
Zdroj: https://emailit.com/cs/docs/templates/mjml/