{"id":195,"date":"2026-11-14T17:45:08","date_gmt":"2026-11-14T17:45:08","guid":{"rendered":"https:\/\/docs.latw.ai\/uncategorized\/translation-memory-and-segments\/"},"modified":"2026-11-14T17:45:08","modified_gmt":"2026-11-14T17:45:08","slug":"translation-memory-and-segments","status":"publish","type":"post","link":"https:\/\/docs.latw.ai\/pl\/latw-multilingual\/translation-memory-and-segments\/","title":{"rendered":"Translation Memory and Segments"},"content":{"rendered":"<p>Posts and pages are not translated as one long text. The plugin cuts each one into <strong>segments<\/strong> &#8211;<br \/>\na paragraph, a heading, a list item, a button label, the alt text of an image &#8211; and keeps a<br \/>\ntranslation for every segment. This is what lets you fix one sentence by hand and have it stay<br \/>\nfixed, and what lets a page that changed a little be translated again without paying for the<br \/>\nparts that did not change.<\/p>\n<p><em>Available in the free version (version 2.8.0 and later). Translating segments automatically with<br \/>\nAI is a <strong>PRO<\/strong> feature (version 2.8.0 and later).<\/em><\/p>\n<h2>What you get<\/h2>\n<ul>\n<li><strong>The same text is translated once.<\/strong> If &#8220;Free shipping on orders over 50 EUR&#8221; appears on ten<br \/>\npages, it is one segment with one translation. Write it once and all ten pages use it. A new page<br \/>\nthat repeats text you have already translated starts out translated, with no AI and no work.<\/li>\n<li><strong>A changed paragraph is the only thing to translate again.<\/strong> Edit one paragraph of the original<br \/>\nand only that paragraph is marked as not translated. The rest of the translation stays as it was.<\/li>\n<li><strong>Your corrections are kept.<\/strong> A segment you wrote or corrected by hand is never replaced by a<br \/>\nlater automatic translation. If you really want to replace it, you do it yourself.<\/li>\n<\/ul>\n<h2>How it behaves<\/h2>\n<h3>When a translation is on the site<\/h3>\n<p>Every translation of a page has a <strong>Published<\/strong> switch in the toolbar of the segment editor,<br \/>\nbefore the other buttons. Under it you read where the translation stands: <strong>On the site<\/strong> or<br \/>\n<strong>Not on the site<\/strong>. It decides whether visitors see that translation, and it takes effect when you<br \/>\nclick <strong>Save changes<\/strong> &#8211; until then the switch says <strong>Save to apply<\/strong>.<\/p>\n<ul>\n<li><strong>Published switched on.<\/strong> Visitors see the translation. The page is rebuilt from its segments<br \/>\neach time one of them changes &#8211; when you save, when AI translates, or when another page that<br \/>\nshares the segment is translated &#8211; so it fills in as the work goes on. Segments without a<br \/>\ntranslation show the original text until they are translated. This also applies when the<br \/>\noriginal changes: a paragraph you changed in the original shows in the original language until<br \/>\nit is translated again.<\/li>\n<li><strong>Published switched off.<\/strong> Visitors see the original, as if the page had no translation: the<br \/>\nlanguage switcher does not offer it, and its translated address does not open it (what happens<br \/>\ninstead follows the <strong>Missing translation<\/strong> setting under <strong>LATW Multilingual \u2192 Settings \u2192<br \/>\nLanguages<\/strong>). Nothing is deleted. You can keep<br \/>\ntranslating, and the switch hides only what visitors get. Switch it back on and save, and the<br \/>\ntranslation is on the site again, with everything you translated in the meantime. In the <strong>LATW<br \/>\nTranslations<\/strong> box the language is marked <strong>not on the site<\/strong>.<\/li>\n<\/ul>\n<p>A page you have never saved in the segment editor has no switch setting yet, and works as it always<br \/>\ndid:<\/p>\n<ul>\n<li>it goes on the site once <strong>every<\/strong> segment has a translation, not before. A new translation does<br \/>\nnot appear with only its title translated;<\/li>\n<li>once it is on the site and the original changes, the translation that is there stays until the<br \/>\nchanged segments are translated, so a visitor never sees half a page in one language and half in<br \/>\nanother. In the <strong>LATW Translations<\/strong> box the language shows as <strong>outdated<\/strong> in the meantime.<\/li>\n<\/ul>\n<p>AI translation of such a page (PRO) therefore puts it on the site as soon as it is complete, as<br \/>\nbefore. The first time you save the page in the segment editor, the switch is set to what you see<br \/>\nin the editor, and from then on the switch decides.<\/p>\n<h3>When the original changes<\/h3>\n<table>\n<thead>\n<tr>\n<th>What you do in the original<\/th>\n<th>What happens in the translations<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Change a paragraph that was translated by AI<\/td>\n<td>That paragraph is marked as not translated; the rest is untouched.<\/td>\n<\/tr>\n<tr>\n<td>Change a paragraph <strong>you<\/strong> had translated by hand<\/td>\n<td>Your version stays on the site and the segment is marked <strong>Needs update<\/strong>. Automatic translation does not touch it.<\/td>\n<\/tr>\n<tr>\n<td>Add, remove or reorder paragraphs (or widgets)<\/td>\n<td>The translation follows the new layout of the original.<\/td>\n<\/tr>\n<tr>\n<td>Save the page without changing the text<\/td>\n<td>Nothing changes.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h3>The same text meaning different things<\/h3>\n<p>A short segment (&#8220;Order&#8221;, &#8220;Home&#8221;, &#8220;Back&#8221;) can mean different things on different pages. When you<br \/>\nsave a translation in the segment editor it is shared by default: every page that contains the same<br \/>\ntext uses it. To keep a translation for one page only, tick <strong>Only in this item<\/strong> next to the<br \/>\nsegment and save &#8211; this works for a segment of any length, and also if you change nothing but the<br \/>\nbox.<\/p>\n<p>Only users who can edit other people&#8217;s posts (Editors and Administrators) change a shared<br \/>\ntranslation. For everyone else &#8211; Authors and Contributors &#8211; a correction always applies only to the<br \/>\npage they made it on, in the segment editor and in the block editor alike, so editing their own post<br \/>\ncannot change a page they may not edit. The segment editor tells them so, and <strong>Only in this item<\/strong><br \/>\nis ticked and cannot be changed.<\/p>\n<h2>The segment editor<\/h2>\n<p>Open a page in <strong>Pages<\/strong> (or any enabled content type) and click the list icon next to a language<br \/>\nin the <strong>LATW Translations<\/strong> box; the editor opens in a new tab, so the page you are editing stays<br \/>\nopen. You can also get there from the <strong>Translations<\/strong> column of the <strong>Pages<\/strong> list and from the<br \/>\n<em>Translations<\/em> screen. Wherever it appears, the number beside the list icon is how many segments<br \/>\nof that language are still to translate; in the box, pointing at the icon also tells you how many<br \/>\nneed an update and whether the layout differs from the original (a <strong>\u2260<\/strong> beside the icon, in the<br \/>\nbox and in the list, marks a translation whose layout differs; see <em>When you change the layout of a<br \/>\ntranslation<\/em>). Every page has the icon;<br \/>\na page translated before this version, and not opened or saved since, shows it without a number<br \/>\nuntil you open it &#8211; its segments are created the moment the editor opens. A page with no text to<br \/>\nsplit (an empty page, or one built with a page builder that is translated as a whole) opens with a<br \/>\nnote saying so. At the top of the editor is the <strong>URL slug<\/strong> of the translation, saved on its own<br \/>\nwith <strong>Save slug<\/strong> (see <em>Translating Elementor<\/em>). Below it you see<br \/>\nevery segment of the page next to its translation, grouped under <strong>Title<\/strong>, <strong>Content<\/strong>,<br \/>\n<strong>Excerpt<\/strong> and so on. Under each original you see where it sits &#8211; the block, or for a page<br \/>\nbuilder the widget and setting (<em>Elementor \u203a icon list \u203a text<\/em>); a link&#8217;s tooltip or an image&#8217;s<br \/>\nalt text is labelled as such. The button next to the page name (<strong>Open in the block editor<\/strong>, or<br \/>\n<strong>Open in Elementor<\/strong> for an Elementor page) opens the translation in the page&#8217;s own editor, and<br \/>\n<strong>View Page<\/strong> (<strong>View Post<\/strong>, <strong>View Product<\/strong>\u2026) opens the translated page on the site in a new<br \/>\ntab; it is not shown while the page has no address visitors can open in that language (a draft,<br \/>\na language it is not translated into yet, or a translation with <strong>Published<\/strong> switched off). <strong>\u2190 Back to Pages<\/strong> above the title returns to<br \/>\n<strong>LATW Multilingual \u2192 Posts<\/strong>.<\/p>\n<ul>\n<li>Type a translation and click <strong>Save changes<\/strong>. What you save is counted as your own work. If you<br \/>\nlater change a segment back to the exact text it had from AI (or from an earlier translation),<br \/>\nit counts as that translation again, not as your correction.<\/li>\n<li><strong>Not translated<\/strong>, <strong>Needs update<\/strong>, <strong>Lost formatting<\/strong> and <strong>All<\/strong> filter the list. For a<br \/>\nsegment that needs an update, the editor shows what the original used to say, so you can see what<br \/>\nchanged. <strong>Lost formatting<\/strong> lists the segments whose translation is missing a link, bold text or<br \/>\nother formatting of the original (see below).<\/li>\n<li><strong>Approve<\/strong> keeps the old translation of a segment that needs an update.<\/li>\n<li><strong>Only in this item<\/strong> saves a translation for this page only, instead of for every page that has<br \/>\nthe same text.<\/li>\n<li><strong>Published<\/strong> decides whether visitors see this translation (see <em>When a translation is on the<br \/>\nsite<\/em> above). It is ticked when the translation is on the site. Change it and click <strong>Save<br \/>\nchanges<\/strong>: you can save the switch alone, without changing any text. A notice above the list<br \/>\nsays where the translation stands: not on the site, on the site with some segments showing the<br \/>\noriginal text, or, if visitors currently see an earlier translation that the segments do not<br \/>\nhold (one made for an older version of the original), that saving with <strong>Published<\/strong> on will<br \/>\nreplace it. In that last case the editor also asks before saving.<\/li>\n<li>A segment marked <strong>Used in N items<\/strong> appears on N pages; changing it changes all of them.<br \/>\nPages that share the segment are updated in the background, about 50 pages every half minute,<br \/>\nso within a few minutes on most sites.<\/li>\n<\/ul>\n<p>Formatting inside a segment &#8211; bold, links, line breaks &#8211; appears as blue tags, exactly as they are<br \/>\nin the original: <code>&lt;br&gt;<\/code> for a line break, <code>&lt;a href=\"https:\/\/example.com\/shop\/\"&gt;<\/code> \u2026 <code>&lt;\/a&gt;<\/code> around the<br \/>\nwords of a link, <code>&lt;strong&gt;<\/code> \u2026 <code>&lt;\/strong&gt;<\/code> around bold text. Point at a tag to see in words what it<br \/>\ndoes (<em>Line break<\/em>, <em>Link to https:\/\/example.com\/shop\/<\/em>, <em>Bold text<\/em>, <em>Image: cat.jpg<\/em>). Keep every<br \/>\ntag exactly as it is, exactly once; you may move it to where it belongs in the translated sentence.<br \/>\nClick a tag to insert it where the cursor is. When a translation loses a tag, repeats it,<br \/>\nchanges it (a different link address, for instance) or closes tags in the wrong order, the editor<br \/>\ndoes not save it and says under that segment which tag is the problem &#8211; so a translation cannot<br \/>\nbreak the formatting. A translation cannot add HTML of its own either (a tag the original does not<br \/>\nhave, typed or written as <code>&amp;lt;\u2026&amp;gt;<\/code>): the editor refuses it and says so under the segment. Only<br \/>\nusers allowed to post unfiltered HTML (on a single site, Administrators and Editors) may do that, as<br \/>\nin the block editor. To give one language a different link address, change it in that language&#8217;s<br \/>\nown editor (<strong>Open in the block editor<\/strong>, <strong>Open in Elementor<\/strong>). Formatting that wraps a whole<br \/>\nsegment (a name in bold, for instance) is not shown at all: it is kept around the translation<br \/>\nautomatically.<\/p>\n<p>An automatic translation that lost a tag is saved anyway, without that formatting (see <em>Translating<br \/>\nwith AI (PRO)<\/em> below). Its row then says <em>This translation lost formatting of the original<\/em>,<br \/>\nfollowed by the tags it lacks, until you put them back or translate the segment again. The <strong>Lost<br \/>\nformatting<\/strong> filter shows only these segments.<\/p>\n<p>The alt text of an image and the title of a link that sit inside a paragraph are segments of their<br \/>\nown, listed right after the paragraph.<\/p>\n<p>Text is shown as you read it on the page: <code>&amp;<\/code> rather than <code>&amp;amp;<\/code>, <code>\u2014<\/code> rather than <code>&amp;mdash;<\/code>. Type<br \/>\ncharacters the same way; the editor writes them into the page correctly.<\/p>\n<p>You can also translate in the block editor as before (the pencil icon next to a language). Whatever you<br \/>\nchange there is filed segment by segment as your own work. Only the text counts: the block editor<br \/>\nwrites the whole page again when you save it, sometimes spelling a character differently (<code>&amp;amp;<\/code><br \/>\nfor <code>&amp;<\/code>, for example), and paragraphs you did not change keep their state.<\/p>\n<h2>When you change the layout of a translation<\/h2>\n<p>The translation is always built from the layout of the original. What happens when you change<br \/>\nthat layout <strong>in the translation<\/strong> depends on the editor.<\/p>\n<h3>Elementor: only the widgets you changed<\/h3>\n<p><em>Version 2.8.1 and later.<\/em><\/p>\n<p>On an Elementor page the plugin knows every widget, section and container by its own identity, so<br \/>\na change of layout applies to the elements you changed, not to the whole page. The rest of the page<br \/>\nkeeps following the original segment by segment: new and changed texts of the original still reach<br \/>\nthe translation, and text you edit in Elementor in the other widgets is filed as your own work.<\/p>\n<ul>\n<li><strong>A widget whose text you gave a structure of its own<\/strong> &#8211; a new paragraph (Enter in a text<br \/>\neditor widget), bold or other formatting the original does not have, pasted formatted text, a<br \/>\nlist item or tab added or removed, a text emptied &#8211; keeps exactly what you saved, settings<br \/>\nincluded. It is no longer updated from the original: if the original&#8217;s text of that widget<br \/>\nchanges, the translation keeps yours.<\/li>\n<li><strong>A widget (or section, or container) you removed<\/strong> stays out of the translation, with<br \/>\neverything in it &#8211; also widgets added to it in the original later.<\/li>\n<li><strong>A widget you added<\/strong> only in the translation stays where you put it. Its text is your own; it<br \/>\nis not a segment, is not translated automatically, and is not in the segment editor&#8217;s table &#8211; to<br \/>\nchange it, use Elementor.<\/li>\n<li><strong>A widget you moved<\/strong> stays in its new place and keeps following the original&#8217;s text.<\/li>\n<\/ul>\n<p>Elements changed, removed or added in the translation are shown in several places, so a change you<br \/>\ndid not mean is easy to spot (a moved element is not: it still shows the original&#8217;s text):<\/p>\n<ul>\n<li>when <strong>Save translation<\/strong> makes elements differ from the original, Elementor says how many, with<br \/>\na button that opens the segment editor;<\/li>\n<li>the segment editor lists them at the top, each named by the beginning of its text, with a<br \/>\n<strong>Restore from the original<\/strong> button &#8211; or, for an element added only in the translation,<br \/>\n<strong>Remove from this translation<\/strong>;<\/li>\n<li>in the segment editor&#8217;s table their segments are greyed out, with no box to type in: <strong>Edited in<br \/>\nthe page builder<\/strong> for a widget with a layout of its own, <strong>Not in this translation<\/strong> for an<br \/>\nelement that is not in the translation. They are not counted as segments to translate. A text<br \/>\nthat also appears in another element of the page, one that still follows the original, stays an<br \/>\nordinary row: the table lists each text once, and the list at the top says so;<\/li>\n<li>the list icon in the <strong>LATW Translations<\/strong> box and in the <strong>Translations<\/strong> column of the<br \/>\n<strong>Pages<\/strong> list gets a small <strong>\u2260<\/strong> mark, and pointing at it says how many elements differ from the<br \/>\noriginal.<\/li>\n<\/ul>\n<p><strong>Restore from the original<\/strong> next to such an element or segment puts that one element back as the<br \/>\noriginal has it: a widget with a layout of its own loses the changes made to it in the translation,<br \/>\nand an element that was not in the translation is shown again. Its texts that already have a<br \/>\ntranslation are filled in; the others show the original text until they are translated, and the<br \/>\ncount of segments <strong>to translate<\/strong> at the top of the editor turns orange so you do not miss them.<br \/>\nRestoring does not translate anything by itself: translate those segments as you would any new<br \/>\ntext. <strong>Remove<br \/>\nfrom this translation<\/strong> takes out an element the original does not have, with everything in it;<br \/>\nwidgets of the original that you had moved into it go back to their place in the original. To put<br \/>\nevery element back at once, use <strong>Translate again, including my edits<\/strong> (PRO, see below).<\/p>\n<p>A translation that an earlier version stopped updating as a whole (<em>This translation&#8217;s layout<br \/>\ndiffers from the original<\/em>) is matched element by element the first time it is listed &#8211; when you<br \/>\nopen its segment editor or its <strong>LATW Translations<\/strong> box, or translate it. The page stays as it was;<br \/>\nfrom then on only the elements that differ are held back. Elements added to the original after the<br \/>\ntranslation stopped being updated count as <strong>Not in this translation<\/strong>; restore them if you want<br \/>\nthem. A layout that cannot be matched element by element (rare: elements without Elementor&#8217;s<br \/>\nidentity) stays as it was, as described next.<\/p>\n<h3>The block editor and Divi: the whole field<\/h3>\n<p>Paragraphs, blocks and Divi modules have no identity of their own, so here a change of layout<br \/>\napplies to the whole field (the content, say). If you add a paragraph, remove a block or move<br \/>\nblocks around in the translation, the plugin notices that the layout no longer matches. It does not<br \/>\ndiscard your work:<\/p>\n<ul>\n<li>your translation stays exactly as you saved it,<\/li>\n<li>the page shows a notice, &#8220;This translation&#8217;s layout differs from the original, so it is no longer<br \/>\nupdated segment by segment&#8221;,<\/li>\n<li>from then on that field is not rebuilt, and PRO does not translate it automatically, so your<br \/>\nlayout is never overwritten.<\/li>\n<\/ul>\n<p>The segment editor shows such a field&#8217;s segments as they relate to your layout. A segment that is<br \/>\nnot on the translated page is marked <strong>Not in this translation<\/strong> instead of <em>Not translated<\/em>, is<br \/>\ngreyed out and has no box to type in &#8211; text typed there would never reach the page. It is not<br \/>\ncounted as a segment to translate, so the page does not keep showing work that cannot be done.<br \/>\nThis happens when a segment has no translation &#8211; new text in the original, or text you changed in<br \/>\nthe original. Your layout is not rebuilt, so the new text is not added to it. (A removed paragraph<br \/>\nthat already has a translation is still listed as translated: the block editor and Divi keep no<br \/>\nidentity that would tell which one you removed.)<\/p>\n<p>To put such text on the page, change it in the translation&#8217;s own editor (<strong>Open in the block<br \/>\neditor<\/strong>, <strong>Open in Divi<\/strong>), or rebuild from the original layout.<\/p>\n<p>To go back, click <strong>Rebuild from the original layout<\/strong> in the notice. Changes you made to the<br \/>\nstructure of the translation are lost; the text of your segments is kept. To start the translation<br \/>\nover instead, text included, use <strong>Translate again, including my edits<\/strong> (PRO, see below).<\/p>\n<h2>Translating with AI (PRO)<\/h2>\n<p>AI translation works on segments too, so it sends the model only what is missing:<\/p>\n<ul>\n<li>The AI icon (the plugin logo, <strong>Translate into \u2026 with AI<\/strong>) next to a language &#8211; in the <strong>LATW<br \/>\nTranslations<\/strong> box of a page and in the <strong>Translations<\/strong> column of the <strong>Pages<\/strong> list (or the<br \/>\nlist of any enabled content type) &#8211; and <strong>Translate<\/strong> in the <strong>Posts<\/strong> screen translate the<br \/>\nsegments that have no translation. The number next to the list icon shows how many are left<br \/>\nbefore you click. On the list, the language&#8217;s dot turns blue while it is being translated and<br \/>\nshows the result when it is done; the number of segments left is updated when you reload the list. Saving a post with <strong>Auto-translate on save<\/strong> switched on translates only the paragraphs you<br \/>\nchanged.<\/li>\n<li><strong>Nothing to translate &#8211; everything is up to date.<\/strong> When no segment is missing, no request is made<br \/>\nand nothing is billed. Segments the translation memory already knows are published without any<br \/>\nrequest.<\/li>\n<li><strong>Translate untranslated with AI<\/strong>, <strong>Translate again<\/strong> and <strong>Translate again, including my edits<\/strong><br \/>\nare in the toolbar of the segment editor (<strong>Segments<\/strong> in the box). <em>Translate again<\/em> sends every<br \/>\nsegment that was translated by AI or imported, and asks for confirmation because it uses your AI<br \/>\nprovider for the whole page. <em>Including my edits<\/em> starts the translation over: every segment is<br \/>\ntranslated again, including what you wrote or confirmed by hand, and the page goes back to the<br \/>\nlayout of the original &#8211; a picture you replaced, a block you added or removed, a colour or link<br \/>\nyou changed in the translation are dropped. It asks for confirmation first, because none of this<br \/>\ncan be restored.<\/p>\n<ul>\n<li>The layout is reset only once the new translation is saved. While the translation runs, and if<br \/>\nit fails, visitors see the page as it was. If even one segment of a field (the content, say)<br \/>\ncomes back unusable, that field keeps its current layout and your wording for that segment;<br \/>\nrun it again to finish.<\/li>\n<li>The new translation is kept for this page only, so other pages that use the same text keep<br \/>\ntheir wording. In the segment editor these segments then count as <strong>Only in this item<\/strong>.<\/li>\n<\/ul>\n<\/li>\n<li><strong>The model sees the surrounding text.<\/strong> When only a few segments are sent, the neighbouring<br \/>\nparagraphs go along as reference, so the new wording matches the page. They are not translated again;<br \/>\nthey only add a little to the input you pay for.<\/li>\n<li><strong>The model gets the same tags you see.<\/strong> A segment is sent with the real tags of the original<br \/>\n(<code>&lt;strong&gt;<\/code>, <code>&lt;a href=\"\u2026\"&gt;<\/code>, <code><\/code>), the way the segment editor shows them, and the model is<br \/>\nasked to keep each one around the words it belongs to. The page always gets the original tags back:<br \/>\na link address, class or style the model changed in a tag is not kept, and a tag it made up is left<br \/>\nout (its words stay).<\/li>\n<li><strong>A segment that lost formatting is still saved.<\/strong> If the model drops a tag &#8211; the link, the bold<br \/>\ntext or the shortcode of a passage &#8211; the segment is saved without it, so the text is translated but<br \/>\nthat formatting is missing on the translated page. The job&#8217;s entry on the <strong>History<\/strong> screen says<br \/>\nso in its <strong>Error<\/strong> column: where each segment is (Content, or the Elementor or Divi setting), how<br \/>\nit begins, and what it lost, in words &#8211; <em>Link to https:\/\/\u2026<\/em>, <em>Bold text<\/em> (up to three segments are<br \/>\nnamed, then how many more). Click the shortened message to read all of it; <strong>Open in the segment<br \/>\neditor<\/strong> next to it opens that page and language with the <strong>Lost formatting<\/strong> filter on, where each<br \/>\nof these segments is marked (see <em>The segment editor<\/em>). Translate them again, or put the tags back<br \/>\nby hand. Machine-translation engines (DeepL, Google<br \/>\nTranslate) are more likely to lose such formatting than AI models.<\/li>\n<li><strong>A segment that comes back unusable is not saved.<\/strong> A segment the model left out or returned empty\n<ul>\n<li>and, with LATW Cloud, one that lost a placeholder such as <code>%s<\/code> &#8211; stays untranslated; the rest of<br \/>\nthe page is saved, and the page shows as outdated until you translate it again or write that segment<br \/>\nyourself. If none of the segments of a job is usable, the job fails and nothing is saved.<\/li>\n<\/ul>\n<\/li>\n<li><strong>MCP assistants<\/strong> work on segments as well, also with real tags, and their changes are treated like<br \/>\nAI translations: your own wording is not replaced. An assistant that drops a tag is told so and asked<br \/>\nto fix it before anything is saved. See <em>Translating from Claude and ChatGPT (MCP)<\/em>.<\/li>\n<li><strong>LATW Cloud<\/strong> &#8211; also in the free version &#8211; is sent only the segments still to translate in each<br \/>\nlanguage, and counts and bills only those words. Segments left out because they came back unusable<br \/>\nare not billed; segments saved without some formatting are, because their text was translated. A<br \/>\npassage edited while LATW Cloud translates the page simply stays to translate; the rest is saved.<br \/>\nSee <em>Translation Engine &#8211; LATW Cloud<\/em>.<\/li>\n<\/ul>\n<h3>Pages built with Elementor or Divi<\/h3>\n<p>An Elementor or Divi page is cut into segments too: each heading, paragraph, button label, tab<br \/>\ntitle, image alt text and so on is one segment, and the layout and design settings around them are<br \/>\nnever touched by a translation. This works once the builder is ticked under <strong>LATW Multilingual \u2192<br \/>\nSettings \u2192 Translation \u2192 Page builders<\/strong>. Everything above applies: a text that repeats is<br \/>\ntranslated once, your corrections are kept, and when you change one widget in the original only its<br \/>\ntext needs translating again.<\/p>\n<p>Only the texts the plugin knows are text are segments. A widget or module from a theme or an<br \/>\nadd-on that the plugin does not know stays in the original language; see <em>Translating Elementor<\/em><br \/>\nand <em>Translating Divi<\/em>.<\/p>\n<ul>\n<li><strong>Settings you change in an Elementor translation are kept for that language.<\/strong> A different<br \/>\npicture, link, colour or alignment saved in the Elementor editor of a translation stays in that<br \/>\nlanguage, and the page still follows the original segment by segment. A setting changed in the<br \/>\noriginal is still taken over, unless you changed that same setting in the translation.<\/li>\n<li><strong>Adding, removing or moving Elementor widgets, or giving a widget&#8217;s text a structure of its own,<br \/>\naffects only those widgets<\/strong> &#8211; the rest of the page still follows the original. See <em>When you<br \/>\nchange the layout of a translation<\/em>. In Divi, any change to the design of a module in the<br \/>\ntranslation counts as a different layout of the whole content.<\/li>\n<li><strong>The alt text of an Elementor picture depends on where the picture comes from.<\/strong> A picture<br \/>\ninserted from a URL keeps its alt text in the widget, so that text is a segment of the page.<br \/>\nA picture from the media library shows the alt text saved in the media library instead. That<br \/>\ntext is translated once for the picture, on the <strong>Media<\/strong> tab of <strong>LATW Multilingual \u2192 Posts<\/strong>,<br \/>\nand every page that uses the picture shows the translation.<\/li>\n<li><strong>Link addresses are not segments.<\/strong> A button&#8217;s or heading&#8217;s link, a video&#8217;s address and similar<br \/>\nsettings are not offered for translation. Links to pages of your own site lead to the visitor&#8217;s<br \/>\nlanguage automatically (the <strong>Internal links in content<\/strong> setting); to send one language<br \/>\nsomewhere else, change the link in that language&#8217;s Elementor editor. A link field you ticked on<br \/>\nthe <em>Elementor Widgets<\/em> screen (PRO) is still translated as text.<\/li>\n<li><strong>The search description is translated too.<\/strong> Elementor keeps a plain-text copy of each page,<br \/>\nwhich search engines and SEO plugins read (an SEO plugin builds its automatic description from<br \/>\nit). The copy of a translated page is put together from the page&#8217;s own segments, so it costs<br \/>\nnothing and needs no work; text the translation memory does not know (a product list, a menu)<br \/>\nstays as it is there.<\/li>\n<\/ul>\n<h2>What it will not do<\/h2>\n<ul>\n<li><strong>It does not split text into sentences.<\/strong> A segment is a whole paragraph. Changing one word of a<br \/>\nlong paragraph means the whole paragraph is translated again.<\/li>\n<li><strong>A large rewrite starts the hand-made translations over.<\/strong> A paragraph you translated by hand is<br \/>\nkept and marked <strong>Needs update<\/strong> when it is changed in the same place. When several hundred paragraphs of one<br \/>\npage change in a single save, the plugin does not try to match old and new ones: the changed<br \/>\nparagraphs are simply not translated, and your old wording stays in the translation memory.<\/li>\n<li><strong>Shortcodes are left alone.<\/strong> A shortcode such as <code><\/code> is kept exactly as it is<br \/>\nand is not translated; neither are its attributes.<\/li>\n<li><strong>Code is not translated.<\/strong> Code blocks, Custom HTML blocks, scripts and styles are left as they<br \/>\nare.<\/li>\n<li><strong>Other page builders are not translated segment by segment.<\/strong> Beaver Builder, Bricks, Oxygen and<br \/>\nWPBakery pages are still translated as a whole, in their own editor.<\/li>\n<li><strong>Terms, menus, classic widgets and strings are not affected.<\/strong> Segments are used for the title,<br \/>\ncontent, excerpt and text custom fields of posts (synced blocks included, when you translate that<br \/>\ncontent type), and for the content of block widgets edited in the block editor. Block widgets<br \/>\ntranslated with AI (PRO) are still translated as before, string by string.<\/li>\n<li><strong>The translation memory is tidied up weekly.<\/strong> Texts that no page or widget uses any more and<br \/>\nthat were never translated are removed. A translation made for one page only (<strong>Only in this<br \/>\nitem<\/strong>, a short text, or a page translated again including your edits) is removed once that page<br \/>\nno longer has the text and the translation has not been changed for a week. Deleting a page<br \/>\npermanently removes its own translations at once. A text that has a shared translation is kept,<br \/>\nso it is still there if the same sentence appears on a new page; older versions of a paragraph<br \/>\nyou have since changed stay in the memory this way too. Revisions and unsaved new posts are never<br \/>\nsplit into segments.<\/li>\n<li><strong>Existing translations are converted gradually.<\/strong> Nothing is changed when you update. A page<br \/>\nthat was translated before this version gets its segments the first time they are listed &#8211; when<br \/>\nyou open the page&#8217;s <strong>LATW Translations<\/strong> box, its segment editor, or translate it again. If the<br \/>\nearlier translation was made for the current text of the original and keeps its layout, each<br \/>\nof its paragraphs becomes the translation of the matching segment, so nothing has to be<br \/>\ntranslated again. For an Elementor page, settings the translation changed (a picture, a link)<br \/>\nare kept for that language, and what the Elementor editor adds or leaves out by itself does not<br \/>\ncount as a different layout; widgets added, removed or changed in structure in the translation<br \/>\nare kept as they are, widget by widget. An earlier translation of the block editor or Divi whose<br \/>\nlayout really differs &#8211; a paragraph added or removed in the translation &#8211; is kept as it is and<br \/>\nmarked <em>This translation&#8217;s layout differs from the original<\/em> (see <em>When you change the layout of<br \/>\na translation<\/em>). Two things are<br \/>\nnot taken over: a text left the same as the original (a name, for example) &#8211; it shows as not<br \/>\ntranslated, and you can confirm it in the segment editor &#8211; and a translation made for an older<br \/>\nversion of the original, because there is no telling which of its paragraphs still match. Such<br \/>\na page stays on the site as it is until its segments are translated; the first AI translation<br \/>\nthen translates all of them, as before, and after that only the changes.<\/li>\n<li><strong>Names of pictures are not text.<\/strong> The title a block keeps for its background or picture comes<br \/>\nfrom the media library (usually the file name, such as <code>leaves-free-img<\/code>) and is not offered for<br \/>\ntranslation, and neither are similar machine names like <code>hero_image<\/code> or <code>photo-2.jpg<\/code> in a title.<\/li>\n<\/ul>\n<h2>What it costs<\/h2>\n<p>Segments cost nothing to keep. Translating them with AI (PRO) spends the same tokens per word as<br \/>\nbefore, but only for segments that are missing, so changing one paragraph of a long page costs one<br \/>\nparagraph. Text already in the translation memory costs nothing.<\/p>\n<h2>Developer reference<\/h2>\n<p>The page is split by <code>LATWM_Segmenter<\/code>; the store and the public API are in <code>LATWM_Segments<\/code>.<\/p>\n<p>Tables (prefix omitted): <code>latwm_segments<\/code> (one row per distinct text, keyed by the hash of the<br \/>\nnormalized text), <code>latwm_segment_translations<\/code> (translation per segment and language; <code>object_type<\/code><br \/>\nempty means shared by all pages, otherwise a translation for one object; <code>origin<\/code> is <code>manual<\/code>,<br \/>\n<code>machine<\/code> or <code>imported<\/code>; <code>status<\/code> is <code>translated<\/code> or <code>review<\/code>; <code>prior_value<\/code> \/ <code>prior_origin<\/code> keep<br \/>\nthe automatic translation a <code>manual<\/code> entry replaced, so saving that text again restores its<br \/>\norigin) and <code>latwm_object_segments<\/code> (which<br \/>\nsegments an object uses, in order). The field row in <code>latwm_translations<\/code> stays what the front end<br \/>\nreads; it is rebuilt from the segments after every change. A field whose layout was changed as a<br \/>\nwhole has <code>detached = 1<\/code> there.<\/p>\n<table>\n<thead>\n<tr>\n<th>Method<\/th>\n<th>Purpose<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td><code>LATWM_Segments::instance()-&gt;pending( $type, $id, $lang, $args )<\/code><\/td>\n<td><code>seg:&lt;id&gt; =&gt; source<\/code> for segments still to translate. Never includes <code>manual<\/code> or <code>review<\/code> ones. <code>include_machine<\/code> adds machine translations (translate again).<\/td>\n<\/tr>\n<tr>\n<td><code>rows( $type, $id, $lang )<\/code><\/td>\n<td>Every segment with source, translation, origin, status and where it is used. <code>absent<\/code> says why a translation of the segment would not reach the page: <code>''<\/code>, <code>removed<\/code> (its element is not in the translation), <code>own<\/code> (its Elementor element has a layout of the translation&#8217;s own) or <code>not_added<\/code> (a detached field never got it); <code>element<\/code> is the Elementor element id that <strong>Restore from the original<\/strong> brings back.<\/td>\n<\/tr>\n<tr>\n<td><code>save_translations( $type, $id, $lang, $values, $origin, $args )<\/code><\/td>\n<td>Stores translations and rebuilds the fields. A machine write never replaces a manual one unless <code>overwrite_manual<\/code> is set. Returns <code>saved<\/code>, <code>cleared<\/code>, <code>skipped_manual<\/code>, <code>invalid_placeholders<\/code>, <code>invalid_markup<\/code> or <code>unknown<\/code> per key. A write is refused as <code>invalid_markup<\/code> when it adds HTML the source does not have &#8211; always for <code>machine<\/code>, and for <code>manual<\/code> when the user lacks <code>unfiltered_html<\/code>. A <code>machine<\/code> value may lack some markers of its source (it is saved without that formatting); a <code>manual<\/code> one may not (<code>invalid_placeholders<\/code>), nor may any value repeat, cross or add markers. A <code>manual<\/code> write is stored for the object only when <code>LATWM_Segments::can_edit_shared()<\/code> is false (default: <code>edit_others_posts<\/code>; filter <code>latwm_can_edit_shared_segments<\/code>).<\/td>\n<\/tr>\n<tr>\n<td><code>assemble( $type, $id, $lang, $args )<\/code><\/td>\n<td>Rebuilds the translated fields, following the Published switch: <code>on<\/code> rebuilds unfinished fields too, <code>off<\/code> rebuilds nothing, no setting waits for complete fields (and for the whole page while nothing is on the site). <code>force_partial<\/code> rebuilds unfinished fields unless the switch is <code>off<\/code>. Returns <code>written<\/code>, <code>incomplete<\/code>, <code>detached<\/code>, <code>none<\/code> or <code>hidden<\/code> per field.<\/td>\n<\/tr>\n<tr>\n<td><code>set_published( $id, $lang, $on )<\/code><\/td>\n<td>Sets the Published switch of a post&#8217;s translation; switching on rebuilds the page at once.<\/td>\n<\/tr>\n<tr>\n<td><code>stats( $type, $id, $lang )<\/code><\/td>\n<td><code>total<\/code>, <code>translated<\/code>, <code>missing<\/code>, <code>review<\/code>, <code>manual<\/code>, <code>detached<\/code>, <code>absent<\/code>, <code>own<\/code>.<\/td>\n<\/tr>\n<tr>\n<td><code>restore_element( $id, $field, $lang, $element )<\/code><\/td>\n<td>Drops the <code>own<\/code> \/ <code>removed<\/code> \/ <code>added<\/code> exception of one Elementor element (an added one is taken out, and elements moved into it go back to the original&#8217;s place) and rebuilds the field.<\/td>\n<\/tr>\n<tr>\n<td><code>context_for( $type, $id, $lang, $keys, $max_chars, $tags )<\/code><\/td>\n<td>Neighbouring segments as read-only context for a translator; <code>$tags = true<\/code> writes them with the original tags.<\/td>\n<\/tr>\n<tr>\n<td><code>with_tags( $type, $id, $fields )<\/code><\/td>\n<td><code>seg:&lt;id&gt;<\/code> values with the original tags in place of the markers, as the segment editor shows them. Other keys pass unchanged.<\/td>\n<\/tr>\n<tr>\n<td><code>from_tags( $type, $id, $sources, $values )<\/code><\/td>\n<td>The reverse: translations written with tags back as markers, repaired so they always fit the page. Returns <code>values<\/code>, and per key <code>missing<\/code> (original tags the translation lacks) and <code>dropped<\/code> (tags left out). Attributes written in a translation are never kept.<\/td>\n<\/tr>\n<tr>\n<td><code>tag_maps( $type, $id )<\/code><\/td>\n<td><code>seg:&lt;id&gt;<\/code> =&gt; the original tag behind each marker (first place in the object).<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Every automatic translation reads and writes posts through <code>LATWM_Content_IO<\/code> (version 2.8.0 and<br \/>\nlater): <code>source_fields( $post, $lang, $args )<\/code> returns the whole fields and the pending segments,<br \/>\n<code>to_tags()<\/code> turns the segments into real tags (<code>with_tags()<\/code>) for the translator, and <code>save_post()<\/code><br \/>\nturns the answer back (<code>from_tags()<\/code>), writes it with <code>save_translations( \u2026, 'machine' )<\/code>, rebuilds the<br \/>\nfields and puts a warning for segments that lost formatting into the History entry<br \/>\n(<code>LATWM_History::complete()<\/code> with <code>meta['warning']<\/code>). LATW Cloud uses it in the free version; PRO&#8217;s<br \/>\nengines and MCP use it through <code>LATWMP_Translator<\/code> (<code>collect_source_fields()<\/code>, <code>to_model()<\/code>,<br \/>\n<code>apply_post_result()<\/code>), which first checks the fields that are not segments. <code>reference()<\/code> gives the<br \/>\nneighbouring translated text that accompanies a partial request (1500 characters; in PRO the<br \/>\n<code>latwmp_segment_context_chars<\/code> filter sets it, 0 turns it off). The toolbar of the segment editor has the<br \/>\n<code>latwm_segments_toolbar<\/code> action for extra buttons. <code>LATWM_Segmenter::validate( $source, $value, $allow_missing )<\/code> returns <code>true<\/code>, or a <code>WP_Error<\/code> when markers are missing (unless <code>$allow_missing<\/code>),<br \/>\nrepeated, unknown or badly nested. <code>LATWM_Segmenter::to_tags()<\/code>, <code>from_tags()<\/code>, <code>repair()<\/code> and<br \/>\n<code>missing_markers()<\/code> do the conversion for a single segment.<\/p>\n<p>A translation made for a whole field before segments existed is taken over by <code>rows()<\/code> (and so by<br \/>\n<code>stats()<\/code> and <code>pending()<\/code>): when the field row&#8217;s <code>source_hash<\/code> matches the current original and the<br \/>\nstored value splits into the original&#8217;s layout, the segments that have no translation get its text<br \/>\nwith <code>origin = imported<\/code>. Each post records in the <code>_latwm_seg_assembled<\/code> meta (language \u2192 field \u2192<br \/>\nsource hash) which field rows already come from the segments, so this happens once per version of<br \/>\nthe original and a segment cleared on purpose is not filled in again. For an Elementor layout the<br \/>\nstored value is first compared with <code>LATWM_Builder_Overrides::compare()<\/code>, as a save from the editor<br \/>\nis.<\/p>\n<p>Per-language differences of an Elementor layout are stored in the post meta<br \/>\n<code>_latwm_builder_overrides<\/code> (JSON, language \u2192 field \u2192 list), laid over every rebuild by the<br \/>\n<code>latwm_segment_assembled<\/code> filter. An entry with <code>path<\/code> is a setting (<code>value<\/code>, or <code>unset<\/code>). An entry<br \/>\nwith <code>kind<\/code> is an element, addressed by Elementor&#8217;s element <code>id<\/code>: <code>own<\/code> (<code>element<\/code>: the element<br \/>\nwithout its children, put in place of the original&#8217;s), <code>removed<\/code>, <code>moved<\/code> (<code>parent<\/code>, <code>after<\/code>) or<br \/>\n<code>added<\/code> (<code>parent<\/code>, <code>after<\/code>, <code>element<\/code> with its children). <code>compare()<\/code> returns these, the saved<br \/>\nlayout brought back to the original&#8217;s structure, and the held elements; only a layout whose<br \/>\nelements cannot be matched by id (an element without one) still marks the field detached. A field<br \/>\nan earlier version detached is matched again by <code>LATWM_Segment_Sync::reattach()<\/code>, called from<br \/>\n<code>rows()<\/code> once per version of the original and of the translation (post meta<br \/>\n<code>_latwm_reattach_tried<\/code>). After an Elementor save, <code>LATWM_Segment_Sync::$last<\/code> holds what that save<br \/>\ndid to the layout; the save response carries it to the editor as <code>latwm_layout<\/code>.<\/p>\n<p>The Published switch is the post meta <code>_latwm_publish_&lt;lang&gt;<\/code> (<code>on<\/code> or <code>off<\/code>; absent means never<br \/>\nset) &#8211; <code>LATWM_Translation_Store::publish_state()<\/code> and <code>set_publish_state()<\/code>. A translation switched<br \/>\noff keeps its rows in <code>latwm_translations<\/code>; the store leaves them out of <code>get_value()<\/code>,<br \/>\n<code>get_object_rows()<\/code> and <code>prime()<\/code>, so no overlay, switcher, hreflang or sitemap sees them, and<br \/>\n<code>find_source_by_slug()<\/code> does not route to them (a uniqueness check, with <code>$exclude_id<\/code>, still<br \/>\ncounts the slug as taken). The translation editor of that post and language, and its preview, still<br \/>\nread them. <code>get_status_map()<\/code> keeps counting them, with <code>hidden =&gt; true<\/code>, so a hidden translation<br \/>\nis not listed as work to do; <code>latwm_object_translated_langs()<\/code> leaves them out. The list of hidden<br \/>\ntranslations is mirrored in the autoloaded <code>latwm_hidden_translations<\/code> option (language \u2192 post ID),<br \/>\nso the serving path checks it without a query. <code>get_stored_value()<\/code> reads a field whatever the<br \/>\nswitch says, for admin screens that edit it. Writes are not affected: anything saved while the<br \/>\nswitch is off is stored and stays hidden.<\/p>\n<p>Elementor&#8217;s plain-text copy in <code>post_content<\/code> is not segmented. After <code>meta:_elementor_data<\/code> is<br \/>\nrebuilt (<code>latwm_field_assembled<\/code>), the copy is translated with <code>LATWM_Segments::from_memory( $type, $id, $lang, $html )<\/code>, which fills in known segments without adding any to the dictionary, and<br \/>\nstored as the <code>post_content<\/code> row; the <code>_latwm_plain_copy<\/code> meta (language \u2192 hash of that row) tells<br \/>\nthese rows apart from a <code>post_content<\/code> translation made another way, which is left alone while it<br \/>\nis up to date. Pages translated before this are done in the background, 20 per WP-Cron run<br \/>\n(<code>latwm_plain_copy_backfill<\/code>, rescheduled until the <code>latwm_plain_copy_todo<\/code> option is empty); an<br \/>\nadmin request only schedules the run.<\/p>\n<p>Link addresses are taken out of the built-in Elementor field list<br \/>\n(<code>latwm_elementor_is_text_path()<\/code>); fields added by the <code>latwm_elementor_widgets_to_translate<\/code><br \/>\nfilter or the Elementor Widgets screen are used as given.<\/p>\n<p>Hooks: action <code>latwm_segments_changed( $object_type, $object_id, $stats )<\/code>; filters<br \/>\n<code>latwm_segmentable_fields<\/code>, <code>latwm_segment_block_tags<\/code> (tags that always end a segment),<br \/>\n<code>latwm_segment_attr_keys<\/code> (block attributes with text) and <code>latwm_block_text_skip<\/code> (blocks left<br \/>\nalone); actions <code>latwm_segments_toolbar<\/code> and <code>latwm_segment_row_actions<\/code> in the segment editor.<br \/>\nThe existing <code>latwm_source_saved<\/code> and <code>latwm_object_saved<\/code> actions are unchanged.<\/p>\n<p>To segment another kind of object, return its markup from the <code>latwm_segment_source_fields<\/code> filter<br \/>\n(<code>field =&gt; [ 'value' =&gt; \u2026, 'format' =&gt; 'html' ]<\/code>, for an <code>$object_type<\/code> other than <code>post<\/code>) and call<br \/>\n<code>LATWM_Segment_Sync::from_field()<\/code> when a person saves its translation. The weekly<br \/>\n<code>latwm_segments_cleanup<\/code> event (<code>LATWM_Segments::run_cleanup()<\/code>) removes, in order: the maps of<br \/>\nposts that are revisions, auto-drafts or no longer exist; per-object translations<br \/>\n(<code>object_type<\/code> not empty) whose segment is no longer in that object&#8217;s map and whose <code>updated_at<\/code> is<br \/>\nmore than a week old &#8211; the map is recomputed from the current original first, at most 200 objects<br \/>\nper run; and dictionary entries older than a week with no object and no translation. Revisions and<br \/>\nauto-drafts are never segmented.<\/p>\n<p>A change to a shared translation reassembles the other objects that use it through the<br \/>\n<code>latwm_reassemble<\/code> WP-Cron event, 50 objects per run. The <code>latwm_reassemble_queue<\/code> option holds<br \/>\njobs (language, changed segment ids, position reached), not objects, and is read and written under<br \/>\na MySQL <code>GET_LOCK<\/code>, so requests that change shared translations at the same time do not lose each<br \/>\nother&#8217;s work.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Posts and pages are not translated as one long text. The plugin cuts each one into segments &#8211; a paragraph, a heading, a list item, a\u2026<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_latwm_translated_slug":"","footnotes":""},"categories":[4],"tags":[],"class_list":["post-195","post","type-post","status-publish","format-standard","hentry","category-latw-multilingual"],"_links":{"self":[{"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/posts\/195","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/comments?post=195"}],"version-history":[{"count":2,"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/posts\/195\/revisions"}],"predecessor-version":[{"id":222,"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/posts\/195\/revisions\/222"}],"wp:attachment":[{"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/media?parent=195"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/categories?post=195"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/docs.latw.ai\/pl\/wp-json\/wp\/v2\/tags?post=195"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}