@ahoo-wang/wow-view-engine 9.2.0-rc.0

package/dist/ui/messages/en.d.ts

@@ -0,0 +1,2098 @@
+/**
+ * English wording for everything this package can report, by area.
+ *
+ * Two namespaces share one flat map: an issue's `code`, and a `label.*` key
+ * for the text a component writes itself. The files above hold one prefix
+ * family each — a flat catalogue could not say which keys were still alive —
+ * and this is the only place they are put back together, so `MessageKey` is
+ * the union of every key the package knows.
+ *
+ * `test/messages.test.tsx` fails when a new issue code has no entry here, so
+ * the catalogue cannot drift behind the kernels.
+ */
+export declare const en: {
+    readonly 'label.reorder.instructions': "Press the arrow keys to move it one place. Press Space to pick it up, the arrow keys to move it, Space again to put it down, or Escape to leave it where it was. Or press the handle to choose where it goes.";
+    readonly 'label.reorder.first': "Move to the start";
+    readonly 'label.reorder.earlier': "Move one place earlier";
+    readonly 'label.reorder.later': "Move one place later";
+    readonly 'label.reorder.last': "Move to the end";
+    readonly 'label.action.more': "Actions for {record}";
+    readonly 'label.action.bulk': "{action} {count}";
+    readonly 'label.action.bulk-able': "{action} {able}/{count}";
+    readonly 'label.action.confirm': "Run “{action}” on {count} records?";
+    readonly 'label.action.confirm-record': "Run “{action}” on {record}?";
+    readonly 'label.action.on-record': "{action}: {record}";
+    readonly 'label.action.record': "Record {record}";
+    readonly 'label.action.left': "The ones refused stay selected, with the reason.";
+    readonly 'label.action.able': "{able} of {count} can take it.";
+    readonly 'label.action.none-able': "None of the {count} can take it now.";
+    readonly 'label.action.refused': "Not sent, and left selected:";
+    readonly 'label.action.refused-keys-more': "{keys} and {count} more";
+    readonly 'label.action.only-able': "Only the {count} that can";
+    readonly 'label.action.only-able-one': "Only the one that can";
+    readonly 'label.action.cancel': "Cancel";
+    readonly 'label.action.required': "Required";
+    readonly 'label.action.unseen': "Not on the page in view";
+    readonly 'label.action.not-offered': "Not offered for this record";
+    readonly 'label.action.unavailable': "Not available now";
+    readonly 'label.action.failed': "Failed, with no reason given";
+    readonly 'label.action.timed-out': "No answer in time";
+    readonly 'label.action.abandoned': "Stopped waiting";
+    readonly 'label.bulk.done': "{done} done";
+    readonly 'label.bulk.failed': "{failed} failed";
+    readonly 'label.bulk.unknown': "{unknown} with outcome unknown, refresh to check first";
+    readonly 'label.bulk.skipped': "{skipped} not run";
+    readonly 'label.bulk.one-done': "{record} done";
+    readonly 'label.bulk.one-failed': "{record} failed: {reason}";
+    readonly 'label.bulk.one-refused': "{record} not run: {reason}";
+    readonly 'label.bulk.one-unknown': "{record}: outcome unknown, refresh to check first";
+    readonly 'label.bulk.one-skipped': "{record} not run";
+    readonly 'label.bulk.reason': "{reason} ({count})";
+    readonly 'label.bulk.more-reasons': "{count} more reasons";
+    readonly 'label.bulk.more-reasons-one': "one more reason";
+    readonly 'label.bulk.left': "the failed and the not run stay selected";
+    readonly 'label.bulk.running': "Running {done} of {total}";
+    readonly 'label.bulk.running-failed': "Running {done} of {total}, {failed} failed";
+    readonly 'label.bulk.stop': "Stop";
+    readonly 'label.bulk.stopping': "Stopping…";
+    readonly 'label.bulk.stop-waiting': "Stop waiting";
+    readonly 'label.bulk.dismiss': "Dismiss";
+    readonly 'label.render.failed': "This part could not be drawn";
+    readonly 'label.render.failed-hint': "The rest of the view still works. Try again to draw this part.";
+    readonly 'label.render.retry': "Try again";
+    readonly 'label.language': "en";
+    readonly 'label.workbench.collapse-sidebar': "Hide the view list";
+    readonly 'label.workbench.expand-sidebar': "Show the view list";
+    readonly 'label.workbench.expand-view': "Fill the screen";
+    readonly 'label.workbench.collapse-view': "Leave full screen";
+    readonly 'label.workbench.switch-view': "Switch view";
+    readonly 'label.workbench.choose-view': "Choose a view";
+    readonly 'label.workbench.opening': "Opening the view";
+    readonly 'label.workbench.editor-modes': "Editor options";
+    readonly 'capability.field.unknown': "The source does not list {field}: it is shown, but no condition, sort or summary uses it.";
+    readonly 'capability.field.unfilterable': "The source admits no condition on {field}.";
+    readonly 'capability.field.operators-narrowed': "The source does not admit {operators} on {field}.";
+    readonly 'capability.field.unsortable': "The source does not sort by {field}.";
+    readonly 'capability.field.alias': "The definition names {path} by its alias {field}: it is read as {path}.";
+    readonly 'capability.field.protected': "{field} is protected: shown, never filtered, sorted or searched by.";
+    readonly 'capability.field.deprecated': "The source deprecates {field}.";
+    readonly 'capability.field.deprecated-because': "The source deprecates {field}: {reason}";
+    readonly 'capability.field.not-projectable': "The source does not return {field}: its column reads empty.";
+    readonly 'capability.field.summary-narrowed': "The source cannot take the {summaries} summary of {field}.";
+    readonly 'capability.field.temporal-mismatch': "{field} is declared as {declared}, but the source keeps it as {described}: its date conditions would be written wrong.";
+    readonly 'capability.field.options-undescribed': "{field} lists {values}, which the source does not declare.";
+    readonly 'capability.search.unavailable': "The source offers no search {field} can use.";
+    readonly 'capability.search.as-terms': "The source matches no phrase, so {field} searches by words.";
+    readonly 'capability.search.fields-narrowed': "{field} cannot search {fields} on this source.";
+    readonly 'capability.record.paging': "The record view pages by {paging}, which the source does not offer.";
+    readonly 'capability.record.cursor-appended': "The source ends a cursor on {appended}, not on the row key {field}.";
+    readonly 'capability.record.row-key-unsortable': "The source cannot sort by the row key {field}.";
+    readonly 'capability.analysis.count': "The source does not count records.";
+    readonly 'capability.analysis.expressions': "The source takes no formulas or derived metrics.";
+    readonly 'capability.analysis.having': "The source keeps no groups by a metric.";
+    readonly 'capability.analysis.metric-sort': "The source orders groups by their dimensions only.";
+    readonly 'capability.analysis.dense': "The source fills no gaps in a time dimension.";
+    readonly 'capability.analysis.unavailable': "The source can aggregate none of what the analysis declares.";
+    readonly 'capability.analysis.element-unavailable': "The source cannot aggregate over the elements of {path}.";
+    readonly 'capability.analysis.field-unavailable': "The source cannot aggregate {field}.";
+    readonly 'capability.analysis.field-narrowed': "The source does not offer {dropped} on {field}.";
+    readonly 'capability.descriptor.disagrees': "{source} refused a query ({code}) its capability descriptor {version} admits: the service and its descriptor disagree.";
+    readonly 'capability.descriptor.unavailable': "The capability descriptor of {source} could not be read; its views run on the definition alone.";
+    readonly 'definition.field.search-fields-unknown': "{field} searches {missing}, which the definition does not declare.";
+    readonly 'definition.field.element-search-fields-required': "{field} searches inside an entry, so it has to name the entry fields it looks in.";
+    readonly 'definition.field.search-mode-invalid': "{field} declares an unknown search mode: {value}.";
+    readonly 'definition.analysis.date-part-not-temporal': "{field} offers grouping by weekday or hour, but holds no date or time.";
+    readonly 'definition.analysis.date-part-unknown': "{field} declares an unknown calendar part: {value}.";
+    readonly 'definition.analysis.default-limit-too-large': "The default row limit exceeds the maximum.";
+    readonly 'definition.analysis.element-field-unknown': "{path} declares no field named {field}.";
+    readonly 'definition.analysis.element-undeclared': "The analysis expands {path}, which is not a field holding elements.";
+    readonly 'definition.analysis.elements-too-many': "The analysis declares more than {max} nested levels.";
+    readonly 'definition.analysis.field-unknown': "The analysis capability names {field}, which the definition does not declare.";
+    readonly 'definition.analysis.limit-invalid': "An analysis limit must be a positive whole number.";
+    readonly 'definition.analysis.no-metric': "The analysis capability offers no metric to start from.";
+    readonly 'definition.field.cell-invalid': "{field} declares an unknown cell renderer: {value}.";
+    readonly 'definition.field.element-title-unknown': "{field} titles its elements by {title}, which its elements do not declare.";
+    readonly 'definition.field.element-title-not-a-value': "{field} titles its elements by {title}, which holds no value of its own to read.";
+    readonly 'definition.field.editor-removed': "{field} declares an editor, which no longer exists; delete the member.";
+    readonly 'definition.field.temporal-invalid': "{field} declares a time storage the engine cannot write: {value}.";
+    readonly 'definition.field.numeric-invalid': "{field} declares a number format the engine cannot write: {value}.";
+    readonly 'definition.field.temporal-misplaced': "{field} declares a time storage, but its type {kind} writes no time.";
+    readonly 'definition.field.time-precision-invalid': "{field} declares an unknown time precision: {value}.";
+    readonly 'definition.field.time-precision-misplaced': "{field} declares a time precision, but reads as {cell}, which has no time of day.";
+    readonly 'definition.field.tone-invalid': "{field} declares an unknown option tone: {value}.";
+    readonly 'definition.field.duplicate': "The field {field} is declared twice.";
+    readonly 'definition.fieldGroup.duplicate': "The group {group} is declared twice.";
+    readonly 'definition.fieldGroup.field-duplicate': "The group {group} lists {field}, which is already listed under another group.";
+    readonly 'definition.fieldGroup.field-unknown': "The group {group} lists {field}, which the definition does not declare.";
+    readonly 'definition.fieldGroup.invalid': "A field group needs an id and a label.";
+    readonly 'definition.field.string-comparison-invalid': "{field} declares an unknown text comparison: {value}.";
+    readonly 'definition.field.kind-unregistered': "{field} uses the unregistered type {kind}.";
+    readonly 'definition.field.name-invalid': "{field} is not a usable field name.";
+    readonly 'definition.id.separator': "A definition id cannot contain {separator}.";
+    readonly 'definition.record.layouts-empty': "The record capability offers no layout.";
+    readonly 'definition.record.max-window-invalid': "The paging window must be a whole number of rows above zero, not {value}.";
+    readonly 'definition.record.max-sort-fields-invalid': "The sort bound must be a whole number of fields, not {value}.";
+    readonly 'definition.record.max-window-cursor': "A paging window bounds pages, and this source pages by cursor.";
+    readonly 'definition.record.row-key-unknown': "The row key {field} is not a declared field.";
+    readonly 'definition.record.row-field-unknown': "The row field {field} is not a declared field.";
+    readonly 'definition.record.row-field-not-a-path': "The row field {field} is a search or metadata handle, not a value a row holds.";
+    readonly 'definition.record.row-key-unsortable': "The row key {field} must be sortable: every page is ordered by it last, so a row never shows on two pages.";
+    readonly 'definition.view.id-duplicate': "Two views share the id {id}.";
+    readonly 'definition.view.id-separator': "A view id cannot contain {separator}.";
+    readonly 'definition.view.kind-mismatch': "A {kind} view does not belong to a {definition} definition.";
+    readonly 'definition.view.analysis-open': "The analyses this view needs come from its source: its snapshot offers none, so it opens only where the source grants some.";
+    readonly 'definition.view.owned-invalid': "The analysis panel {panel} holds is incomplete or set up wrong.";
+    readonly 'definition.field.undescribed': "{field} is not a path the source’s descriptor lists.";
+    readonly 'definition.field.kind-unknown': "The descriptor does not say what kind of value {field} holds; give it a kind.";
+    readonly 'definition.field.unlabelled': "{field} has no label of its own, so it is shown by its description or its path.";
+    readonly 'definition.field.deprecated': "{field} is deprecated by its source ({message}); say why it is kept.";
+    readonly 'definition.field.not-elements': "{field} is not an array whose entries the source lists.";
+    readonly 'definition.field.sort-wider': "{field} does not sort at its source.";
+    readonly 'definition.field.operator-wider': "{field} does not take {operator} at its source.";
+    readonly 'definition.field.summary-wider': "{field} cannot be summarised by {fn} at its source.";
+    readonly 'definition.field.analysis-wider': "{field} does not offer {what} to analyses at its source.";
+    readonly 'definition.option.undescribed': "{value} is not one of the values the source lists for {field}.";
+    readonly 'definition.analysis.wider': "The source does not offer {what} to analyses.";
+    readonly 'definition.record.paging-wider': "The source does not page by {paging}.";
+    readonly 'definition.timeField.unknown': "The time field {field} is not a field of the definition.";
+    readonly 'definition.timeField.not-time': "The time field {field} is not a moment.";
+    readonly 'definition.text.unknown': "No words are given for the key {key}.";
+    readonly 'definition.text.fallback': "The words in force give none for the key {key}; the engine’s starting words say it instead.";
+    readonly 'definition.source.unregistered': "No source is registered for {source}: register this definition with its source.";
+    readonly 'definition.descriptor.missing': "No descriptor was given for the source {source}, so its capabilities go unchecked.";
+    readonly 'label.status.show': "Show {count}";
+    readonly 'label.status.less': "Show less";
+    readonly 'label.status.loading': "Loading";
+    readonly 'label.status.querying': "Running the query";
+    readonly 'label.status.then': "{first}; {then}";
+    readonly 'label.status.groups': "{count} groups";
+    readonly 'label.status.groups-one': "1 group";
+    readonly 'label.status.open-columns': "Open column settings";
+    readonly 'label.status.open-sort': "Open sort settings";
+    readonly 'label.status.open-card': "Open card settings";
+    readonly 'label.status.use-page-size': "Show {size} per page";
+    readonly 'label.status.use-layout': "Switch to {layout}";
+    readonly 'label.query.failed': "The query failed";
+    readonly 'label.query.forbidden': "No permission";
+    readonly 'label.query.stale': "{error} · Showing the last successful result";
+    readonly 'label.query.stale-conditions': "{error} · Showing the result from before the conditions changed";
+    readonly 'label.query.retry': "Try again";
+    readonly 'label.write.conflict': "Someone else saved this view first";
+    readonly 'label.write.unknown': "The result never came back";
+    readonly 'label.image.failed': "This image could not be loaded";
+    readonly 'label.image.link': "Open the linked page";
+    readonly 'label.embed.locked': "Set by this page";
+    readonly 'label.embed.unavailable-removed': "Conditions its data source no longer offers are left out here; the saved view is unchanged.";
+    readonly 'label.embed.locked-name': "{filter} (set by this page)";
+    readonly 'label.embed.any': "Any";
+    readonly 'label.drill.board': "Dashboard filters: {conditions}";
+    readonly 'label.drill.away': "(opens in the workbench)";
+    readonly 'label.click.badge': "Click filters “{filter}”";
+    readonly 'label.click.badge-note': "Pressing a group of this panel sets “{filter}” for the rest of the dashboard; pressing it again clears it.";
+    readonly 'label.click.from': "from “{panel}”";
+    readonly 'label.click.filtered': "“{filter}” now filters by the group pressed";
+    readonly 'label.click.filtered-to': "“{filter}” now filters by the group pressed: {group}";
+    readonly 'label.click.cleared': "“{filter}” no longer filters by the group pressed";
+    readonly 'label.click.no-value': "This group has no value “{filter}” can take";
+    readonly 'label.click.menu-item': "When clicked…";
+    readonly 'label.click.title': "When “{panel}” is clicked";
+    readonly 'label.click.description': "What pressing one group of this panel does — a bar, a slice, a row of its table.";
+    readonly 'label.click.choice': "A press";
+    readonly 'label.click.menu': "Open the follow-up menu";
+    readonly 'label.click.menu-hint': "See these records, split the group by another dimension, or ask of it alone — each opens in the workbench.";
+    readonly 'label.click.menu-no-route': "This page opens no workbench, so a press does nothing here.";
+    readonly 'label.click.filter': "Update a dashboard filter";
+    readonly 'label.click.filter-hint': "The other wired panels are filtered by the value pressed; this panel keeps every group and marks the one pressed. Press it again to clear.";
+    readonly 'label.click.filter-none': "Wire a filter to a field this panel groups by first.";
+    readonly 'label.click.filter-pick': "Filter";
+    readonly 'label.click.go': "Go to another view, dashboard or page";
+    readonly 'label.click.go-hint': "The value pressed goes along.";
+    readonly 'label.click.go-kind': "Destination";
+    readonly 'label.click.go-view': "View";
+    readonly 'label.click.go-url': "Web address";
+    readonly 'label.click.view-pick': "Choose a view…";
+    readonly 'label.click.view-change': "Choose another…";
+    readonly 'label.click.view-missing': "Choose the view a press opens.";
+    readonly 'label.click.view-heading': "Where a press on “{panel}” goes";
+    readonly 'label.click.url': "Address";
+    readonly 'label.click.url-hint': "Write one of these where the value pressed goes: {fields}";
+    readonly 'label.click.url-hint-none': "This panel has no dimension to pass on.";
+    readonly 'label.click.url-invalid': "Only http, https, mailto or an address inside this application.";
+    readonly 'label.click.go-board': "Dashboard";
+    readonly 'label.click.board-pick': "Choose a dashboard…";
+    readonly 'label.click.board-change': "Choose another…";
+    readonly 'label.click.board-missing': "Choose the dashboard a press opens.";
+    readonly 'label.click.board-heading': "Which dashboard a press on “{panel}” opens";
+    readonly 'label.click.board-description': "Its filters are listed next, for you to say what each one takes.";
+    readonly 'label.click.board-list-loading': "Loading dashboards…";
+    readonly 'label.click.board-list-empty': "There is no saved dashboard yet.";
+    readonly 'label.click.board-list-none': "No dashboard matches.";
+    readonly 'label.click.board-values': "Its filters";
+    readonly 'label.click.board-values-hint': "For each, the value of one dimension of the group pressed, what one of this dashboard’s filters holds, or nothing; one not carried starts at its default.";
+    readonly 'label.click.board-value': "This group’s {dimension}";
+    readonly 'label.click.board-skip': "Not carried";
+    readonly 'label.click.board-tab': "Opens on";
+    readonly 'label.click.board-tab-last': "The tab its reader last read";
+    readonly 'label.click.board-no-source': "Neither a dimension of this panel nor a filter of this dashboard’s fits it.";
+    readonly 'label.click.board-no-filters': "That dashboard has no filters: a press opens it as it is.";
+    readonly 'label.click.board-loading': "Reading its filters…";
+    readonly 'label.click.board-unreadable': "That dashboard was deleted, or you may not open it.";
+    readonly 'label.click.board-stale': "What went to {filters} no longer applies — that filter, this panel’s dimension or this dashboard’s filter is gone — and is dropped on Done.";
+    readonly 'label.click.board-filter-value': "This board’s {filter}";
+    readonly 'label.click.board-from-group': "The group pressed";
+    readonly 'label.click.board-from-board': "This board’s filters";
+    readonly 'label.click.board-stale-name': "“{filter}”";
+    readonly 'label.click.save': "Done";
+    readonly 'dashboard.click.invalid': "This panel’s click setting cannot be read; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.unpressable': "This panel has no groups to press — a record view, or an analysis over expanded elements — so its click setting does nothing.";
+    readonly 'dashboard.click.filter-unknown': "The filter this panel’s click sets is no longer on the dashboard; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.filter-unwired': "“{filter}” is not wired to this panel, so a press cannot set it; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.filter-ungrouped': "This panel does not group by {field}, which “{filter}” is wired to, so a press has no value for it; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.url-unsafe': "The click’s address is not http, https, mailto or inside this application; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.url-unknown-field': "The click’s address names {field}, which this panel does not group by; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.destination-unavailable': "The view a press goes to was deleted, or you may not open it.";
+    readonly 'dashboard.click.destination-unsupported': "A view destination is a record or an analysis view; for a dashboard, choose “Dashboard”.";
+    readonly 'dashboard.click.view-unknown': "The view a press goes to cannot be found in this application; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.view-undeclared': "“{definition}” has no view like the one a press goes to; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.view-not-a-view': "What a press goes to is not a record or an analysis view; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.board-dimension-unknown': "The click carries {field} to another dashboard, which this panel no longer groups by; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.board-gone': "The dashboard a press opens was deleted, or you may not open it; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.board-not-a-board': "What the click opens is not a dashboard; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.board-filter-unknown': "The dashboard a press opens no longer has the filter “{filter}”; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.board-filter-mismatch': "“{filter}” on the dashboard a press opens cannot take {field}; pressing it opens the follow-up menu.";
+    readonly 'dashboard.click.board-source-unknown': "The click carries this dashboard’s filter “{filter}” to another dashboard, but this dashboard no longer has it; pressing it opens the follow-up menu.";
+    readonly 'label.filters.bar': "Filters";
+    readonly 'label.filters.required': "(required)";
+    readonly 'label.filters.clear': "Clear";
+    readonly 'label.filters.clear-one': "Clear “{filter}”";
+    readonly 'label.filters.back-to-default': "Put “{filter}” back to its default";
+    readonly 'label.filters.idle': "Nothing on this tab is filtered by “{filter}”, so it changes nothing here.";
+    readonly 'label.filters.grouping': "Time grouping";
+    readonly 'label.filters.grouping-remove': "Remove the time grouping";
+    readonly 'label.filters.fixed': "Fixed scope";
+    readonly 'label.filters.fixed-note': "The dashboard itself holds every panel to this; it cannot be changed here.";
+    readonly 'label.filters.fixed-remove': "Remove the fixed scope";
+    readonly 'label.filters.fixed-removed': "Removed the fixed scope";
+    readonly 'label.filters.sheet-set': "Filters ({count} set)";
+    readonly 'label.filters.not-reached': "Not filtered by {filters}";
+    readonly 'label.filters.name-quoted': "“{name}”";
+    readonly 'label.filters.add': "Add filter";
+    readonly 'label.filters.add-grouping': "Time grouping";
+    readonly 'label.filters.type.date': "Date";
+    readonly 'label.filters.type.text': "Text or category";
+    readonly 'label.filters.type.id': "ID";
+    readonly 'label.filters.type.number': "Number";
+    readonly 'label.filters.type.boolean': "Yes or no";
+    readonly 'label.filters.type.search': "Search";
+    readonly 'label.filters.search-placeholder': "Search…";
+    readonly 'label.filters.removed': "Removed the filter “{filter}”";
+    readonly 'label.filters.outcome': "Filtered by {filters}; {count} panels updated.";
+    readonly 'label.filters.outcome-one': "Filtered by {filters}; 1 panel updated.";
+    readonly 'label.filters.outcome-cleared': "Cleared {filters}; {count} panels updated.";
+    readonly 'label.filters.outcome-cleared-one': "Cleared {filters}; 1 panel updated.";
+    readonly 'label.filters.outcome-failed': " {count} panels could not load.";
+    readonly 'label.filters.outcome-failed-one': " 1 panel could not load.";
+    readonly 'label.filters.settings-of': "Settings of “{filter}”";
+    readonly 'label.filters.type': "Type";
+    readonly 'label.filters.name': "Name";
+    readonly 'label.filters.default': "Default";
+    readonly 'label.filters.multiple': "Several values";
+    readonly 'label.filters.required-toggle': "Required";
+    readonly 'label.filters.required-hint': "Always has a value: clearing it goes back to the default.";
+    readonly 'label.filters.one-day-toggle': "One day only";
+    readonly 'label.filters.one-day-hint': "A day off the calendar, or today, yesterday or the day before; never a range.";
+    readonly 'label.filters.date-own': "Each panel's own dates";
+    readonly 'label.filters.required-needs-default': "A required filter needs a default to start at.";
+    readonly 'label.filters.source': "Values from";
+    readonly 'label.filters.source.fields': "The wired fields";
+    readonly 'label.filters.source.list': "A list of its own";
+    readonly 'label.filters.source.fields-hint': "The values the wired fields declare; where they declare none, the values the data holds, with how many records hold each.";
+    readonly 'label.filters.source.list-hint': "A few fixed values, typed here.";
+    readonly 'label.filters.list': "The values";
+    readonly 'label.filters.wire': "Wire to panels";
+    readonly 'label.filters.remove': "Remove the filter";
+    readonly 'label.filters.wiring': "Wiring “{filter}”";
+    readonly 'label.filters.wiring-hint': "On each panel, pick the field it is filtered through.";
+    readonly 'label.filters.wiring-done': "Done wiring";
+    readonly 'label.filters.wire-field': "Filter field";
+    readonly 'label.filters.wire-field-of': "Field of “{panel}” filtered by “{filter}”";
+    readonly 'label.filters.unwired': "Not wired";
+    readonly 'label.filters.no-field': "No field to wire";
+    readonly 'label.filters.manual': "Manual";
+    readonly 'label.filters.manual-hint': "Wired by hand rather than by name";
+    readonly 'label.filters.auto-wired': "Wired {count} more panels with a “{field}” field automatically";
+    readonly 'label.filters.auto-wired-one': "Wired 1 more panel with a “{field}” field automatically";
+    readonly 'label.filters.auto-wired-search': "Wired {count} more panels with a search box automatically";
+    readonly 'label.filters.auto-wired-search-one': "Wired 1 more panel with a search box automatically";
+    readonly 'label.filters.only-picked': "Only the panel picked";
+    readonly 'label.filters.dismiss': "Dismiss";
+    readonly 'label.filters.toasts': "Wiring notices";
+    readonly 'label.filters.refused': "Some of the filters in the link could not be used";
+    readonly 'label.filters.reorder': "Reorder “{filter}”";
+    readonly 'label.filters.picked': "Picked up the filter “{filter}”.";
+    readonly 'label.filters.cancelled': "The filter “{filter}” stayed where it was.";
+    readonly 'label.filters.moved': "“{filter}” is now filter {index} of {total}";
+    readonly 'label.tabs.name': "Tabs";
+    readonly 'label.tabs.add': "Add a tab";
+    readonly 'label.tabs.new-title': "Tab {index}";
+    readonly 'label.tabs.first-title': "Overview";
+    readonly 'label.tabs.actions': "Tab “{title}”";
+    readonly 'label.tabs.rename': "Rename";
+    readonly 'label.tabs.rename-field': "Name of tab “{title}”";
+    readonly 'label.tabs.remove': "Delete tab";
+    readonly 'label.tabs.reorder': "Reorder “{title}”";
+    readonly 'label.tabs.picked': "Picked up the tab “{title}”.";
+    readonly 'label.tabs.cancelled': "The tab “{title}” stayed where it was.";
+    readonly 'label.tabs.moved': "“{title}” is now tab {index} of {total}";
+    readonly 'label.tabs.removed': "The tab “{title}” was deleted";
+    readonly 'label.tabs.remove-heading': "Delete the tab “{title}”?";
+    readonly 'label.tabs.remove-description': "Its {count} panels are deleted with it. Nothing is saved until you finish editing; Undo brings them back.";
+    readonly 'label.tabs.remove-description-one': "Its one panel is deleted with it. Nothing is saved until you finish editing; Undo brings it back.";
+    readonly 'label.tabs.remove-confirm': "Delete tab and panels";
+    readonly 'label.tabs.empty': "This tab has no panels yet";
+    readonly 'label.tabs.empty-hint': "Add a view or an analysis while it is shown, or move a panel here from another tab.";
+    readonly 'label.panel.moved-to-tab': "“{title}” moved to the tab “{tab}”";
+    readonly 'label.panel.new-analysis.heading': "New analysis";
+    readonly 'label.panel.new-analysis.heading-of': "New analysis · {definition}";
+    readonly 'label.panel.new-analysis.description': "It belongs to this dashboard: saved, shared and deleted with it, and never listed among the views.";
+    readonly 'label.panel.new-analysis.data': "Data";
+    readonly 'label.panel.new-analysis.pick': "Choose the data to analyse";
+    readonly 'label.panel.new-analysis.pick-hint': "Only data that can be analysed is listed here.";
+    readonly 'label.panel.new-analysis.none': "None of the data here can be analysed";
+    readonly 'label.panel.new-analysis.failed': "This data could not be opened: {reason}";
+    readonly 'label.panel.new-analysis.close-visualization': "Close the visualization";
+    readonly 'label.panel.new-analysis.title': "Title";
+    readonly 'label.panel.new-analysis.title-hint': "Named after what it shows until you name it.";
+    readonly 'label.panel.new-analysis.add': "Put on the dashboard";
+    readonly 'label.panel.new-analysis.blocked': "Fix what the analysis says above before putting it on the dashboard.";
+    readonly 'label.panel.new-analysis.added': "“{title}” was put on the dashboard";
+    readonly 'label.panel.new-analysis.full': "This dashboard holds as many panels as it can.";
+    readonly 'label.panel.save-owned.heading': "Save as a view";
+    readonly 'label.panel.save-owned.description': "It becomes a view of {definition} that can be opened in the workbench, and this panel shows that view from now on.";
+    readonly 'label.panel.save-owned.submit': "Save view";
+    readonly 'label.panel.save-owned.saved': "“{title}” was saved as a view; this panel shows it now";
+    readonly 'label.panel.copy-shared.heading': "Copy as a shared view and replace";
+    readonly 'label.panel.copy-shared.description': "“{view}” is a personal view, so the other readers of this shared dashboard see nothing in this panel. It is copied as a shared view of {definition}, saved right away, and this panel shows the copy — looking and filtering as it does now. The personal view stays as it is. Done saves the dashboard.";
+    readonly 'label.panel.copy-shared.submit': "Copy and replace";
+    readonly 'label.panel.copy-shared.saved': "“{title}” was copied as a shared view; this panel shows it now";
+    readonly 'label.panel.copy-system.heading': "Copy as a system view and replace";
+    readonly 'label.panel.copy-system.description': "“{view}” is not a system view, so readers in other tenants see nothing in this panel of a system dashboard. It is copied as a system view of {definition}, saved right away, and this panel shows the copy — looking and filtering as it does now. The original view stays as it is. Done saves the dashboard.";
+    readonly 'label.panel.copy-system.saved': "“{title}” was copied as a system view; this panel shows it now";
+    readonly 'label.panel.presentation.reset': "Look as the view does";
+    readonly 'label.panel.presentation.heading': "How “{title}” looks here";
+    readonly 'label.panel.presentation.description': "Only this panel changes. The view it shows keeps its own look, and what it asks stays the same.";
+    readonly 'label.panel.presentation.done': "Done";
+    readonly 'label.panel.presentation.preview': "This panel as it will look";
+    readonly 'label.panel.presentation.nothing': "This panel has no result to draw yet. Try again once it has one.";
+    readonly 'label.panel.presentation.as': "Shown here as {type}";
+    readonly 'label.panel.presentation.changed': "Shown differently here";
+    readonly 'label.panel.presentation.note': "This panel looks different from the view it shows, on purpose: it was changed for this dashboard only.";
+    readonly 'label.dashboard.needs-fixing': "This dashboard needs fixing before it runs";
+    readonly 'label.dashboard.panels-need-fixing': "{count} panels need fixing before they can show";
+    readonly 'label.dashboard.panels-need-fixing-one': "1 panel needs fixing before it can show";
+    readonly 'label.dashboard.new': "New dashboard";
+    readonly 'label.dashboard.new-title': "Untitled dashboard";
+    readonly 'label.dashboard.none': "No dashboard yet";
+    readonly 'label.dashboard.more': "More dashboard actions";
+    readonly 'label.dashboard.leave-heading': "Leave this dashboard?";
+    readonly 'label.dashboard.refresh-on': "This dashboard refreshes itself every {interval}.";
+    readonly 'label.dashboard.list': "Dashboards";
+    readonly 'label.dashboard.manage-group': "Actions for the dashboard “{title}”";
+    readonly 'label.dashboard.publish': "Publish as a system dashboard";
+    readonly 'label.dashboard.publish-failed': "This dashboard could not be published as a system dashboard.";
+    readonly 'label.dashboard.publish-forbidden': "You may not publish system dashboards; ask an administrator.";
+    readonly 'label.dashboard.delete-system-consequence': "Once it is deleted, no one sees this system dashboard any more.";
+    readonly 'label.dashboard.collapse-sidebar': "Hide the dashboard list";
+    readonly 'label.dashboard.expand-sidebar': "Show the dashboard list";
+    readonly 'label.dashboard.switch': "Switch dashboard";
+    readonly 'label.dashboard.choose': "Choose a dashboard";
+    readonly 'label.dashboard.opening': "Opening the dashboard";
+    readonly 'label.dashboard.write-conflict': "Someone else saved this dashboard first";
+    readonly 'label.dashboard.scope-refused': "This page could not narrow this dashboard";
+    readonly 'label.dashboard.render-hint': "The rest of the dashboard still works. Try again to draw this part.";
+    readonly 'label.dashboard.unopenable': "This dashboard could not be opened";
+    readonly 'label.dashboard.open-default': "Open the default dashboard";
+    readonly 'label.dashboard.save-group': "Dashboard actions";
+    readonly 'label.dashboard.saved-announce': "Dashboard saved";
+    readonly 'label.dashboard.shared-heading': "Update the dashboard for everyone?";
+    readonly 'label.dashboard.first-heading': "Save this dashboard";
+    readonly 'label.dashboard.save-as.heading': "Save as a new dashboard";
+    readonly 'label.dashboard.save-as.description': "The dashboard you are looking at stays as it is.";
+    readonly 'label.dashboard.save-as.submit': "Create dashboard";
+    readonly 'label.dashboard.delete-consequence': "Only the dashboard is removed: its records and the saved views its panels show stay, and the analyses made inside it go with it.";
+    readonly 'label.dashboard.group.personal': "My dashboards";
+    readonly 'label.dashboard.group.shared': "Shared dashboards";
+    readonly 'label.dashboard.group.system': "System dashboards";
+    readonly 'label.dashboard.manage': "Manage dashboards";
+    readonly 'label.dashboard.manage-description': "Rename, reorder and delete dashboards, and pick the one that opens by default.";
+    readonly 'label.dashboard.config-invalid': "Fix what this dashboard reports before saving it.";
+    readonly 'label.dashboard.create-forbidden': "You may not create dashboards here.";
+    readonly 'label.dashboard.audience-failed': "Who this dashboard is for could not be changed.";
+    readonly 'label.dashboard.audience-forbidden': "You may not change who this dashboard is for; save a copy of your own instead.";
+    readonly 'label.dashboard.audience-unsupported': "This store cannot move a dashboard between personal and shared.";
+    readonly 'label.dashboard.audience-invalid': "Who this dashboard is for could not be changed: {reason}";
+    readonly 'label.dashboard.audience-shared-boards': "This dashboard stays shared: shared dashboards show it ({boards}).";
+    readonly 'label.dashboard.audience-shared-boards-one': "This dashboard stays shared: a shared dashboard shows it ({boards}).";
+    readonly 'label.dashboard.delete-failed': "This dashboard could not be deleted.";
+    readonly 'label.dashboard.delete-forbidden': "You may not delete this dashboard; ask whoever owns it to remove it.";
+    readonly 'label.dashboard.list-failed': "The list of dashboards could not be loaded.";
+    readonly 'label.dashboard.list-unavailable': "The list of dashboards could not be loaded: the server could not be reached.";
+    readonly 'label.dashboard.list-unavailable-server': "The list of dashboards could not be loaded: the server could not handle it ({reason}).";
+    readonly 'label.dashboard.list-unsupported': "The list of dashboards could not be loaded: this server keeps no dashboards.";
+    readonly 'label.dashboard.reserved-id': "The stored dashboard {id} uses a reserved id and was skipped.";
+    readonly 'label.dashboard.notify-failed': "A listener on dashboard changes failed: {reason}. The list may be a revision behind.";
+    readonly 'label.dashboard.open-failed': "This dashboard could not be opened.";
+    readonly 'label.dashboard.not-found': "No dashboard named {id}.";
+    readonly 'label.dashboard.wrong-kind': "This is not a dashboard ({kind}), so this page cannot show it.";
+    readonly 'label.dashboard.other-definition': "This dashboard belongs to another page, so this page cannot show it.";
+    readonly 'label.dashboard.gone': "This dashboard no longer exists.";
+    readonly 'label.dashboard.open-forbidden': "You do not have access to this dashboard. Ask an administrator to grant it.";
+    readonly 'label.dashboard.open-unavailable': "This dashboard could not be loaded: the server could not be reached.";
+    readonly 'label.dashboard.open-unavailable-server': "This dashboard could not be loaded: the server could not handle it ({reason}).";
+    readonly 'label.dashboard.open-unsupported': "This dashboard could not be loaded: this server keeps no dashboards.";
+    readonly 'label.dashboard.write-unsupported': "This server keeps no dashboards.";
+    readonly 'label.dashboard.default-forbidden': "You may not set the default dashboard.";
+    readonly 'label.dashboard.preferences-failed': "Your dashboard preferences could not be saved.";
+    readonly 'label.dashboard.preferences-load-failed': "Your dashboard preferences could not be loaded; the dashboards are in the server’s order.";
+    readonly 'label.dashboard.reorder-forbidden': "You may not reorder dashboards.";
+    readonly 'label.dashboard.rename-failed': "This dashboard could not be renamed.";
+    readonly 'label.dashboard.rename-forbidden': "You may not rename this dashboard; save a copy of your own instead.";
+    readonly 'label.dashboard.not-open': "This dashboard is not open here any more.";
+    readonly 'label.dashboard.save-as-failed': "This dashboard could not be saved as a copy.";
+    readonly 'label.dashboard.save-failed': "This dashboard could not be saved.";
+    readonly 'label.dashboard.save-forbidden': "You may not save changes to this dashboard; save a copy of your own instead.";
+    readonly 'label.dashboard.system-read-only': "A built-in dashboard cannot be changed ({action}).";
+    readonly 'label.dashboard.title-empty': "A dashboard needs a title.";
+    readonly 'label.dashboard.title-too-long': "A dashboard’s title can be at most {max} characters.";
+    readonly 'label.dashboard.config-too-large': "This dashboard is too large to save: {size} KB, where the store keeps at most {max} KB.";
+    readonly 'label.dashboard.write-in-flight': "This dashboard is already being saved; wait for that to finish.";
+    readonly 'label.dashboard.write-forbidden': "You may not write to this dashboard.";
+    readonly 'label.dashboard.unreadable': "This dashboard could not be read.";
+    readonly 'label.dashboard.refresh-missing': "This dashboard has no refresh setting.";
+    readonly 'label.dashboard.not-declared': "{definition} does not offer dashboards.";
+    readonly 'label.dashboard.empty': "This dashboard has no panels yet";
+    readonly 'label.dashboard.empty-hint': "A dashboard puts saved record and analysis views side by side.";
+    readonly 'label.panel.awaiting-date': "Pick a date";
+    readonly 'label.panel.awaiting-date-hint': "{filter} is set to a specific date; pick one to see the numbers for it.";
+    readonly 'label.panel.untitled': "Panel {index}";
+    readonly 'label.panel.more-rows': "{count} more rows below";
+    readonly 'label.panel.more-rows-one': "1 more row below";
+    readonly 'label.panel.more-columns': "{count} more columns to the right";
+    readonly 'label.panel.more-columns-one': "1 more column to the right";
+    readonly 'label.panel.more-both': "{rows}, {columns}";
+    readonly 'label.panel.more-below': "More below";
+    readonly 'label.panel.numbered': "{name} {n}";
+    readonly 'label.panel.kind.heading': "Heading";
+    readonly 'label.panel.kind.markdown': "Text";
+    readonly 'label.panel.kind.image': "Image";
+    readonly 'label.panel.kind.links': "Links";
+    readonly 'label.panel.out.missing': "The view this panel shows was deleted, or you do not have access to it";
+    readonly 'label.panel.out.failed': "The view this panel shows could not be opened";
+    readonly 'label.panel.out.kind': "This panel points at something that is not a record or analysis view";
+    readonly 'label.panel.out.private': "The view this panel shows is not open to everyone who reads this dashboard";
+    readonly 'label.panel.out.filter': "The dashboard's filters do not fit this panel";
+    readonly 'label.panel.out.config': "This panel cannot be used";
+    readonly 'label.panel.out.blocked': "The dashboard itself needs fixing first";
+    readonly 'label.panel.out.unknown-kind': "This type of panel cannot be shown here";
+    readonly 'label.panel.out.settings': "This panel's own settings cannot be used";
+    readonly 'label.panel.way-out.maintainer': "Ask whoever maintains this dashboard to replace or remove this panel.";
+    readonly 'label.panel.way-out.share': "Ask the view's owner to share it with you, or whoever maintains this dashboard to replace or remove this panel.";
+    readonly 'label.panel.way-out.widen': "Ask the view's owner to share it as widely as this dashboard, or whoever maintains this dashboard to replace or remove this panel.";
+    readonly 'label.panel.way-out.author': "Ask the view's owner to open it and fix it, or whoever maintains this dashboard to replace this panel.";
+    readonly 'label.panel.way-out.dashboard': "This panel runs again once the dashboard is fixed.";
+    readonly 'label.panel.way-out.retry': "Try again. If it keeps failing, ask whoever maintains this dashboard.";
+    readonly 'label.panel.retry': "Try again";
+    readonly 'label.panel.finding': "{panel}: {finding}";
+    readonly 'label.panel.resize': "Resize “{title}”";
+    readonly 'label.panel.handle': "Move or resize “{title}”";
+    readonly 'label.panel.handle-hint': "Drag it, or press Enter to arrange it with the keyboard: the arrows move it, Shift and the arrows resize it, Enter finishes, Escape puts it back.";
+    readonly 'label.panel.arranging': "Arranging “{title}”: the arrows move it, Shift and the arrows resize it, Enter finishes, Escape puts it back";
+    readonly 'label.panel.arranged': "“{title}” stays where it is";
+    readonly 'label.panel.arrange-cancelled': "“{title}” is back where it was";
+    readonly 'label.panel.arrange-stuck': "“{title}” cannot go that way";
+    readonly 'label.panel.resize-any': "Resize this panel";
+    readonly 'label.panel.placed': "{title} is at column {column}, row {row}, {width} by {height}";
+    readonly 'label.panel.columns': "{count} columns";
+    readonly 'label.panel.columns-one': "1 column";
+    readonly 'label.panel.rows': "{count} rows";
+    readonly 'label.panel.rows-one': "1 row";
+    readonly 'label.link.new-tab': "(opens in a new tab)";
+    readonly 'label.dashboard.edit': "Edit";
+    readonly 'label.dashboard.editing': "Editing";
+    readonly 'label.dashboard.editing-hint': "Panels run as you change them; nothing is kept until you save.";
+    readonly 'label.dashboard.save': "Save";
+    readonly 'label.dashboard.width': "Dashboard width";
+    readonly 'label.dashboard.width-fixed': "Fixed width";
+    readonly 'label.dashboard.width-full': "Full width";
+    readonly 'label.dashboard.add': "Add";
+    readonly 'label.dashboard.add.data': "Data";
+    readonly 'label.dashboard.add.content': "Content";
+    readonly 'label.dashboard.add.saved-view': "Saved view…";
+    readonly 'label.dashboard.add.new-analysis': "New analysis…";
+    readonly 'label.dashboard.add.heading': "Heading";
+    readonly 'label.dashboard.add.markdown': "Text…";
+    readonly 'label.dashboard.add.image': "Image…";
+    readonly 'label.dashboard.add.links': "Links…";
+    readonly 'label.dashboard.empty.add-view': "Add a view…";
+    readonly 'label.dashboard.empty.add-heading': "Add a heading";
+    readonly 'label.dashboard.new-heading': "New heading";
+    readonly 'label.dashboard.added': "Added “{title}”";
+    readonly 'label.dashboard.duplicated': "Copied “{title}”";
+    readonly 'label.dashboard.removed': "Removed “{title}”. Undo brings it back.";
+    readonly 'label.history.undo': "Undo";
+    readonly 'label.history.redo': "Redo";
+    readonly 'label.history.undo-step': "Undo {what}";
+    readonly 'label.history.redo-step': "Redo {what}";
+    readonly 'label.history.undone': "Undone: {what}";
+    readonly 'label.history.redone': "Redone: {what}";
+    readonly 'label.history.add-panel': "adding “{title}”";
+    readonly 'label.history.remove-panel': "removing “{title}”";
+    readonly 'label.history.move-panel': "moving “{title}”";
+    readonly 'label.history.change-panel': "the change to “{title}”";
+    readonly 'label.history.add-tab': "adding a tab";
+    readonly 'label.history.remove-tab': "deleting a tab";
+    readonly 'label.history.change-tabs': "the change to the tabs";
+    readonly 'label.history.add-filter': "adding the filter “{title}”";
+    readonly 'label.history.remove-filter': "removing the filter “{title}”";
+    readonly 'label.history.change-filter': "the change to the filter “{title}”";
+    readonly 'label.history.change-grouping': "the change to the time grouping";
+    readonly 'label.history.remove-fixed': "removing the fixed scope";
+    readonly 'label.history.change-width': "the change to the dashboard width";
+    readonly 'label.history.change-board': "the last change";
+    readonly 'label.dashboard.tab.untitled': "Tab {index}";
+    readonly 'label.picker.add-heading': "Add a saved view";
+    readonly 'label.picker.replace-heading': "Replace the view in “{title}”";
+    readonly 'label.picker.description': "Pick a record or analysis view to show on this dashboard.";
+    readonly 'label.picker.search': "Search by name";
+    readonly 'label.picker.kind': "Kind";
+    readonly 'label.picker.kind.all': "All";
+    readonly 'label.picker.kind.record': "Records";
+    readonly 'label.picker.kind.analysis': "Analyses";
+    readonly 'label.picker.definition': "Data";
+    readonly 'label.picker.definition.all': "All data";
+    readonly 'label.picker.on-board': "On the dashboard";
+    readonly 'label.picker.private': "Only you can see it";
+    readonly 'label.picker.none': "No view matches.";
+    readonly 'label.picker.empty': "There is no saved record or analysis view yet.";
+    readonly 'label.picker.loading': "Loading views…";
+    readonly 'label.panel.menu': "Actions for “{title}”";
+    readonly 'label.panel.pagination': "Pages of “{title}”";
+    readonly 'label.panel.menu.view': "Data";
+    readonly 'label.panel.menu.edit': "Edit panel";
+    readonly 'label.panel.open': "Open in the workbench";
+    readonly 'label.panel.refresh': "Refresh this panel";
+    readonly 'label.panel.export': "Export data…";
+    readonly 'label.panel.rename': "Rename";
+    readonly 'label.panel.edit-presentation': "Change how it looks here…";
+    readonly 'label.panel.edit-content': "Edit content…";
+    readonly 'label.panel.replace': "Replace view…";
+    readonly 'label.panel.copy-shared': "Copy as a shared view and replace…";
+    readonly 'label.panel.copy-system': "Copy as a system view and replace…";
+    readonly 'label.panel.duplicate': "Duplicate";
+    readonly 'label.panel.move-to-tab': "Move to tab";
+    readonly 'label.panel.arrange-menu': "Move or resize";
+    readonly 'label.panel.step.left': "Move left";
+    readonly 'label.panel.step.right': "Move right";
+    readonly 'label.panel.step.up': "Move up";
+    readonly 'label.panel.step.down': "Move down";
+    readonly 'label.panel.step.wider': "Wider";
+    readonly 'label.panel.step.narrower': "Narrower";
+    readonly 'label.panel.step.taller': "Taller";
+    readonly 'label.panel.step.shorter': "Shorter";
+    readonly 'label.panel.save-as-view': "Save as a view…";
+    readonly 'label.panel.remove': "Remove from dashboard";
+    readonly 'label.panel.reorder': "Reorder “{title}”";
+    readonly 'label.panel.picked': "Picked up the panel “{title}”.";
+    readonly 'label.panel.cancelled': "The panel “{title}” stayed where it was.";
+    readonly 'label.panel.reordered': "“{title}” is now panel {index} of {total}";
+    readonly 'label.panel.title-input': "Panel title";
+    readonly 'label.panel.heading-input': "Heading text";
+    readonly 'label.panel.way-out.edit': "Replace it with another view, or remove it from the dashboard.";
+    readonly 'label.panel.way-out.edit-content': "Change what it holds, or remove it from the dashboard.";
+    readonly 'label.content.markdown.add': "Add text";
+    readonly 'label.content.markdown.edit': "Edit text";
+    readonly 'label.content.markdown.field': "Text";
+    readonly 'label.content.markdown.hint': "Markdown: **bold**, lists, [links](https://…).";
+    readonly 'label.content.markdown.placeholder': "Write what this dashboard is for.";
+    readonly 'label.content.image.add': "Add an image";
+    readonly 'label.content.image.edit': "Edit image";
+    readonly 'label.content.image.src': "Image address";
+    readonly 'label.content.image.alt': "Description";
+    readonly 'label.content.image.alt-hint': "Read out to whoever cannot see the image.";
+    readonly 'label.content.image.href': "Opens when pressed (optional)";
+    readonly 'label.content.image.fit': "Fit";
+    readonly 'label.content.image.fit.contain': "Whole image";
+    readonly 'label.content.image.fit.cover': "Fill and crop";
+    readonly 'label.content.links.add': "Add links";
+    readonly 'label.content.links.edit': "Edit links";
+    readonly 'label.content.links.item': "Link {n}";
+    readonly 'label.content.links.label': "Link text";
+    readonly 'label.content.links.href': "Address";
+    readonly 'label.content.links.description': "Note (optional)";
+    readonly 'label.content.links.more': "Add a link";
+    readonly 'label.content.links.drop': "Remove link {n}";
+    readonly 'label.content.title': "Panel title (optional)";
+    readonly 'label.content.required': "Fill this in.";
+    readonly 'label.content.submit-add': "Add";
+    readonly 'label.content.submit-edit': "Update";
+    readonly 'dashboard.binding.global-duplicate': "{field} is mapped twice on this panel.";
+    readonly 'dashboard.binding.global-unknown': "{field} is not a filter field of this dashboard.";
+    readonly 'dashboard.binding.kind-mismatch': "A {global} field cannot filter a {panel} field.";
+    readonly 'dashboard.binding.missing': "This panel does not carry the {field} filter, so it cannot be filtered with the others.";
+    readonly 'dashboard.binding.panel-unknown': "“{filter}” is wired to a field the view this panel shows does not have.";
+    readonly 'dashboard.field.duplicate': "The filter field {field} is declared twice.";
+    readonly 'dashboard.field.name-empty': "A filter field needs a name.";
+    readonly 'dashboard.field.name-invalid': "{field} is not a usable field name.";
+    readonly 'dashboard.field.not-multiple': "The filter {field} takes one value, and this holds several.";
+    readonly 'dashboard.field.not-one-day': "The filter {field} holds one day: a day off the calendar, or today, yesterday or the day before.";
+    readonly 'dashboard.field.one-day-not-date': "The filter {field} is not a date filter, so it cannot be held to one day.";
+    readonly 'dashboard.field.options-empty': "The filter {field} picks from a list of its own, and the list is empty.";
+    readonly 'dashboard.field.required-no-default': "The filter {field} always has a value, so it needs a default to start at.";
+    readonly 'dashboard.fields.too-many': "A dashboard holds at most {max} filters.";
+    readonly 'dashboard.filter.unknown': "This dashboard has no filter {field}.";
+    readonly 'dashboard.filter.held': "The page holds the filter {field}; it cannot be changed here.";
+    readonly 'dashboard.scope.unsupported': "A dashboard takes no outer condition: lock or hide its filters instead.";
+    readonly 'dashboard.grouping.kept': "This panel keeps its own time grouping: its data cannot be grouped the way the dashboard is.";
+    readonly 'dashboard.grouping.unit-duplicate': "The time grouping offers {unit} twice.";
+    readonly 'dashboard.grouping.unit-unknown': "{unit} is not a time grouping this dashboard offers.";
+    readonly 'dashboard.grouping.units-empty': "The time grouping offers nothing to choose from.";
+    readonly 'dashboard.grid.unsupported': "This dashboard is laid out on a grid that cannot be drawn here; panels are placed on {columns} columns.";
+    readonly 'dashboard.heading.too-long': "A heading holds at most {max} characters.";
+    readonly 'dashboard.layout.invalid': "This panel has an unusable position or size.";
+    readonly 'dashboard.layout.missing': "This panel has no position.";
+    readonly 'dashboard.layout.out-of-grid': "This panel reaches past the {columns} columns of the grid.";
+    readonly 'dashboard.link.label-empty': "A link needs a label.";
+    readonly 'dashboard.links.too-many': "A links panel holds at most {max} links.";
+    readonly 'dashboard.markdown.too-long': "A text panel holds at most {max} characters.";
+    readonly 'dashboard.panel.definition-unknown': "The data the analysis in this panel was built on is no longer available.";
+    readonly 'dashboard.panel.failed': "The view this panel shows could not be opened.";
+    readonly 'dashboard.panel.id-duplicate': "Two panels share the id {id}.";
+    readonly 'dashboard.panel.id-empty': "A panel needs an id.";
+    readonly 'dashboard.panel.kind-unsupported': "This panel points at something that is not a record or analysis view.";
+    readonly 'dashboard.panel.not-owned': "Only an analysis that lives in this dashboard can be saved as a view.";
+    readonly 'dashboard.panel.not-referenced': "This panel does not show a saved view you have open, so there is nothing to copy.";
+    readonly 'dashboard.panel.owned-invalid': "The analysis this panel holds is not in the expected shape.";
+    readonly 'dashboard.panel.view-unknown': "The view this panel shows cannot be found in this application.";
+    readonly 'dashboard.panel.view-undeclared': "“{definition}” has no view like the one this panel shows.";
+    readonly 'dashboard.panel.opens-unknown': "The view this panel was set to open in the workbench cannot be found in this application, so it opens the panel's own view.";
+    readonly 'dashboard.panel.opens-undeclared': "“{definition}” has no view like the one this panel was set to open in the workbench, so it opens the panel's own view.";
+    readonly 'dashboard.panel.opens-elsewhere': "The view this panel was set to open in the workbench, “{view}”, is over “{definition}”, not this panel's data, so it opens the panel's own view.";
+    readonly 'dashboard.panel.opens-invalid': "The view this panel was set to open in the workbench is not named properly, so it opens the panel's own view.";
+    readonly 'dashboard.panel.presentation-dropped': "How this panel was set to look no longer fits its view, so it shows the view's own look.";
+    readonly 'dashboard.system.non-system-panels': "These panels reference views that are not system views; publish those as system views first: {panels}";
+    readonly 'dashboard.panel.scope-too-narrow': "The view this panel shows is not open to everyone who reads this dashboard.";
+    readonly 'dashboard.panel.source-invalid': "This panel should show either a saved view or an analysis of its own.";
+    readonly 'dashboard.panel.tab-unknown': "This panel is on no tab of this dashboard, so it is shown on the first.";
+    readonly 'dashboard.panel.unavailable': "The view this panel shows was deleted, or you do not have access to it.";
+    readonly 'dashboard.panel.unknown-kind': "This type of panel is not available.";
+    readonly 'dashboard.panels.too-many': "A dashboard holds at most {max} panels.";
+    readonly 'dashboard.shape.invalid': "This part of the dashboard is not in the expected shape.";
+    readonly 'dashboard.tab.id-duplicate': "Two tabs share the id {id}.";
+    readonly 'dashboard.tab.id-empty': "A tab needs an id.";
+    readonly 'dashboard.tab.title-empty': "A tab has no name, so it is called by its place.";
+    readonly 'dashboard.tabs.too-many': "A dashboard holds at most {max} tabs.";
+    readonly 'dashboard.url.unsupported-scheme': "Only http, https, mailto and relative links can be shown.";
+    readonly 'dashboard.width.unknown': "This dashboard’s width “{width}” is not one this release knows, so it is shown full width. Choose fixed width or full width while editing.";
+    readonly 'label.analysis.row-count': "Record count";
+    readonly 'label.analysis.caption': "Showing {count} groups · took {seconds} s";
+    readonly 'label.analysis.caption-one': "Showing 1 group · took {seconds} s";
+    readonly 'label.analysis.caption-whole': "Took {seconds} s";
+    readonly 'label.analysis.answered': "Result updated";
+    readonly 'label.analysis.editor': "Analysis";
+    readonly 'label.analysis.slot.range': "Range";
+    readonly 'label.analysis.slot.dimensions': "Dimensions";
+    readonly 'label.analysis.slot.metrics': "Metrics";
+    readonly 'label.analysis.slot.result': "Result";
+    readonly 'label.analysis.slot.elements': "Expand";
+    readonly 'label.analysis.tip-of': "About {term}";
+    readonly 'label.analysis.tip.elements': "Counts the entries of an array in each record: once {name} is expanded, each {name} counts as one, and the metrics and dimensions are chosen from its fields. You can go one level further in.";
+    readonly 'label.analysis.tip.metrics': "The numbers to work out: a record count, a sum or an average of a field, each optionally over only the records that match. Drag to reorder; a derived metric stays after the ones it reads.";
+    readonly 'label.analysis.tip.dimensions': "What to compare by: each dimension cuts the result into groups, and several cut it in turn.";
+    readonly 'label.analysis.tip.result': "Which groups to keep and in what order: keep only the groups that match, order them by a dimension or a metric, and take the top N.";
+    readonly 'label.analysis.tip.range': "Which records are counted. It narrows the outermost records, and expanding does not change it.";
+    readonly 'label.analysis.add': "Add";
+    readonly 'label.analysis.dropped.expand': "Expanding {name} took out {what}";
+    readonly 'label.analysis.dropped.collapse': "Collapsing {name} took out {what}";
+    readonly 'label.analysis.dropped.edit': "This change also took out {what}";
+    readonly 'label.analysis.dropped.metric': "1 metric: {names}";
+    readonly 'label.analysis.dropped.metrics': "{count} metrics: {names}";
+    readonly 'label.analysis.dropped.dimension': "1 dimension: {names}";
+    readonly 'label.analysis.dropped.dimensions': "{count} dimensions: {names}";
+    readonly 'label.analysis.dropped.both': "{first}; {second}";
+    readonly 'label.analysis.dropped.undo': "Undo";
+    readonly 'label.analysis.dropped.dismiss': "Dismiss";
+    readonly 'label.analysis.dropped.undone': "Undone; the question is back as it was";
+    readonly 'label.analysis.move-stop.after': "{name} is calculated from {other}, so it stays after it.";
+    readonly 'label.analysis.move-stop.before': "{other} is calculated from {name}, so {name} stays before it.";
+    readonly 'label.analysis.remove-last': "An analysis needs at least one metric.";
+    readonly 'label.analysis.remove-cascade': "Every other metric is calculated from this one; removing it would leave none.";
+    readonly 'label.analysis.expand-into': "Expand into {name}";
+    readonly 'label.analysis.collapse': "Stop expanding {name}";
+    readonly 'label.analysis.unit': "Counting: {name}";
+    readonly 'label.analysis.records': "records";
+    readonly 'label.analysis.element-condition-of': "Conditions on the entries of {name}";
+    readonly 'label.analysis.element-condition-title': "Only entries where";
+    readonly 'label.analysis.element-condition': "Conditions on the entries";
+    readonly 'label.analysis.conditions-mode': "Conditions: {mode}";
+    readonly 'label.analysis.granularity': "Granularity";
+    readonly 'label.date-unit.YEAR': "By year";
+    readonly 'label.date-unit.QUARTER': "By quarter";
+    readonly 'label.date-unit.MONTH': "By month";
+    readonly 'label.date-unit.WEEK': "By week";
+    readonly 'label.date-unit.DAY': "By day";
+    readonly 'label.date-unit.HOUR': "By hour";
+    readonly 'label.date-unit.MINUTE': "By minute";
+    readonly 'label.date-unit.SECOND': "By second";
+    readonly 'label.analysis.date-part': "Cycle";
+    readonly 'label.date-part.DAY_OF_WEEK': "By weekday";
+    readonly 'label.date-part.HOUR_OF_DAY': "By hour of day";
+    readonly 'label.date-part.DAY_OF_MONTH': "By day of month";
+    readonly 'label.date-part.MONTH_OF_YEAR': "By month of year";
+    readonly 'label.analysis.part.DAY_OF_WEEK': "{field} (weekday)";
+    readonly 'label.analysis.part.HOUR_OF_DAY': "{field} (hour of day)";
+    readonly 'label.analysis.part.DAY_OF_MONTH': "{field} (day of month)";
+    readonly 'label.analysis.part.MONTH_OF_YEAR': "{field} (month of year)";
+    readonly 'label.analysis.dated.YEAR': "{field} (by year)";
+    readonly 'label.analysis.dated.QUARTER': "{field} (by quarter)";
+    readonly 'label.analysis.dated.MONTH': "{field} (by month)";
+    readonly 'label.analysis.dated.WEEK': "{field} (by week)";
+    readonly 'label.analysis.dated.DAY': "{field} (by day)";
+    readonly 'label.analysis.dated.HOUR': "{field} (by hour)";
+    readonly 'label.analysis.dated.MINUTE': "{field} (by minute)";
+    readonly 'label.analysis.dated.SECOND': "{field} (by second)";
+    readonly 'label.analysis.band': "{from}–{to}";
+    readonly 'label.analysis.interval': "Band width";
+    readonly 'label.analysis.percentile': "Percentile";
+    readonly 'label.analysis.open-editor': "Open analysis";
+    readonly 'label.analysis.open-chart-options': "Open chart options";
+    readonly 'label.analysis.reading': "By {dimensions} · {metrics}";
+    readonly 'label.analysis.reading-flat': "{metrics}";
+    readonly 'label.analysis.reading-kept': "{reading} · Keep only {conditions}";
+    readonly 'label.analysis.reading-kept-row': "{metric} {operator} {value}";
+    readonly 'label.analysis.reading-kept-custom': "{reading} · Keep only groups matching a custom rule";
+    readonly 'label.analysis.layout': "Show result as";
+    readonly 'label.analysis.add-group': "Add dimension";
+    readonly 'label.analysis.group-by-currency': "Group by {field}";
+    readonly 'label.analysis.add-metric': "Add metric";
+    readonly 'label.analysis.add-formula': "Formula";
+    readonly 'label.analysis.add-derived': "Derived metric";
+    readonly 'label.analysis.add-duration': "Time between two moments";
+    readonly 'label.analysis.duration-from': "From which time, for {name}";
+    readonly 'label.analysis.duration-to': "To which time, for {name}";
+    readonly 'label.analysis.duration-unit': "Unit of {name}";
+    readonly 'label.date-diff-unit.SECOND': "Seconds";
+    readonly 'label.date-diff-unit.MINUTE': "Minutes";
+    readonly 'label.date-diff-unit.HOUR': "Hours";
+    readonly 'label.date-diff-unit.DAY': "Days";
+    readonly 'label.analysis.group-by-duration': "Group by this duration";
+    readonly 'label.analysis.derived.style-of': "How {name} reads";
+    readonly 'label.analysis.derived.style.number': "Number";
+    readonly 'label.analysis.derived.style.percent': "Percent";
+    readonly 'label.analysis.derived.style.currency': "Money";
+    readonly 'label.analysis.derived.decimals': "Decimals of {name}";
+    readonly 'label.analysis.derived.currency': "Currency of {name}";
+    readonly 'label.analysis.derived.currency-inherited': "As its operands";
+    readonly 'label.analysis.operand-left': "Left side of {name}";
+    readonly 'label.analysis.operand-right': "Right side of {name}";
+    readonly 'label.analysis.operand-number': "A number";
+    readonly 'label.analysis.operand-value': "Number in {name}";
+    readonly 'label.analysis.operator': "Operation of {name}";
+    readonly 'label.analysis.expression-unreadable': "This metric is written with an expression the card cannot show.";
+    readonly 'label.analysis.having': "Add condition";
+    readonly 'label.analysis.having-first': "Keep only…";
+    readonly 'label.analysis.having-title': "Keep only";
+    readonly 'label.analysis.having-row': "Keep-only condition {index}";
+    readonly 'label.analysis.having-and': "and";
+    readonly 'label.analysis.having-metric': "Metric to keep by";
+    readonly 'label.analysis.having-operator': "Comparison";
+    readonly 'label.analysis.having-value': "Value to compare with";
+    readonly 'label.analysis.remove-having': "Remove this condition";
+    readonly 'label.analysis.having-note': "Groups without a value are not kept.";
+    readonly 'label.analysis.having-unreadable': "This view keeps groups by a rule this editor cannot show.";
+    readonly 'label.analysis.clear-having': "Clear";
+    readonly 'label.having.op.GT': "more than";
+    readonly 'label.having.op.GTE': "at least";
+    readonly 'label.having.op.LT': "less than";
+    readonly 'label.having.op.LTE': "at most";
+    readonly 'label.having.op.EQ': "equal to";
+    readonly 'label.having.op.NE': "not equal to";
+    readonly 'label.analysis.totals': "Totals row";
+    readonly 'label.analysis.totals-whole': "With no dimension the one row is every record in the range, so there is no totals row.";
+    readonly 'label.analysis.row-limit': "Top N groups";
+    readonly 'label.analysis.row-limit-invalid': "A whole number from 1 to {max}";
+    readonly 'label.analysis.row-limit-unsorted': "Unsorted, the source decides which groups";
+    readonly 'label.analysis.totals-scope': "Every record in the range";
+    readonly 'label.analysis.totals-hidden.cut': "Includes groups past the first {limit}";
+    readonly 'label.analysis.totals-hidden.maybe-cut': "May include groups past the first {limit}";
+    readonly 'label.analysis.totals-hidden.kept': "Includes groups Keep only removed";
+    readonly 'label.analysis.approximate': "Approximate";
+    readonly 'label.analysis.any-note': "Any value: it may differ from one run to the next.";
+    readonly 'label.analysis.first-last-note': "Opening and closing values are the values on the group’s earliest and latest record.";
+    readonly 'label.analysis.order-by-of': "Order of {name}";
+    readonly 'label.analysis.order-by-default': "By event time";
+    readonly 'label.analysis.order-by': "By {field}";
+    readonly 'label.analysis.visualize': "Visualize";
+    readonly 'label.analysis.auto-run': "Run automatically";
+    readonly 'label.analysis.auto-run-hint': "Changes to dimensions, metrics and the result run on their own; the range waits for Apply.";
+    readonly 'label.analysis.auto-run-held': "The range has conditions not applied (or not filled in); nothing runs until Apply.";
+    readonly 'label.chart.picker': "Visualization";
+    readonly 'label.chart.picker-back': "Back to the views";
+    readonly 'label.chart.recommended': "Recommended";
+    readonly 'label.chart.group.suits': "Fits this result";
+    readonly 'label.chart.group.others': "Other charts";
+    readonly 'chart.fit.needs-dimension': "Needs a dimension";
+    readonly 'chart.fit.needs-one-dimension': "Needs exactly one dimension";
+    readonly 'chart.fit.needs-two-dimensions': "Needs two dimensions";
+    readonly 'chart.fit.too-many-dimensions': "At most two dimensions";
+    readonly 'chart.fit.needs-two-metrics': "Needs two metrics";
+    readonly 'chart.fit.needs-no-dimension': "Not with dimensions";
+    readonly 'chart.fit.needs-quantity': "Needs an amount; a time is not drawn";
+    readonly 'chart.fit.needs-category': "Stages need a category dimension";
+    readonly 'chart.fit.needs-two-stages': "Needs two groups or more as stages";
+    readonly 'chart.fit.not-steps': "These groups are categories side by side, not the steps of one process";
+    readonly 'chart.fit.needs-additive': "Needs a count or a sum";
+    readonly 'chart.fit.needs-share': "Shares hold only for a count or a sum";
+    readonly 'chart.fit.needs-five-numbers': "Needs a field’s minimum, three percentiles and maximum";
+    readonly 'chart.fit.needs-date': "Needs one date dimension";
+    readonly 'chart.fit.needs-ohlc': "Needs a field’s opening value, maximum, minimum and closing value";
+    readonly 'chart.fit.needs-three-metrics': "Needs three metrics or more";
+    readonly 'chart.fit.too-many-levels': "At most four dimensions";
+    readonly 'chart.fit.needs-day': "Needs one date dimension by day";
+    readonly 'chart.fit.needs-date-and-split': "Needs a date and one more dimension";
+    readonly 'chart.fit.needs-region': "Needs one dimension of regions by value";
+    readonly 'chart.fit.needs-map': "No map is available here";
+    readonly 'label.chart.hint.metric': "The number and its change";
+    readonly 'label.chart.hint.gauge': "Where it stands on a scale";
+    readonly 'label.chart.options': "{name} options";
+    readonly 'label.chart.options-back': "Back to the chart types";
+    readonly 'label.chart.tab.data': "Data";
+    readonly 'label.chart.tab.display': "Display";
+    readonly 'label.chart.tab.axes': "Axes";
+    readonly 'label.chart.slot.x': "Horizontal axis";
+    readonly 'label.chart.slot.split': "Split by";
+    readonly 'label.chart.slot.series': "Series";
+    readonly 'label.chart.add-series': "Add series";
+    readonly 'label.chart.remove-series': "Remove series {name}";
+    readonly 'label.chart.reorder': "Reorder {name}";
+    readonly 'label.chart.moved': "{name} moved to position {index} of {total}";
+    readonly 'label.chart.picked': "{name} picked up";
+    readonly 'label.chart.cancelled': "Move cancelled; {name} stayed where it was";
+    readonly 'label.chart.mark-of': "Drawn as, for {name}";
+    readonly 'label.chart.axis-of': "Axis for {name}";
+    readonly 'label.chart.mark.bar': "Bars";
+    readonly 'label.chart.mark.line': "Line";
+    readonly 'label.chart.mark.area': "Area";
+    readonly 'label.chart.axis.left': "Left axis";
+    readonly 'label.chart.axis.right': "Right axis";
+    readonly 'label.chart.slot.category': "Slices by";
+    readonly 'label.chart.slot.value': "Value";
+    readonly 'label.chart.slot.rows': "Vertical dimension";
+    readonly 'label.chart.slot.columns': "Horizontal dimension";
+    readonly 'label.chart.slot.point': "One point per";
+    readonly 'label.chart.slot.x-metric': "Across";
+    readonly 'label.chart.slot.y-metric': "Up";
+    readonly 'label.chart.slot.size': "Point size";
+    readonly 'label.chart.slot.none': "None";
+    readonly 'label.chart.slot.stages': "Stages";
+    readonly 'label.chart.stage-name': "Name of the stage {name}";
+    readonly 'label.chart.slot.stage-of': "Stages are the values of";
+    readonly 'label.chart.slot.steps': "One step per";
+    readonly 'label.chart.slot.tiles': "One tile per";
+    readonly 'label.chart.slot.parent': "Grouped in";
+    readonly 'label.chart.waterfall.total': "Show the total";
+    readonly 'label.chart.slot.box': "One box per";
+    readonly 'label.chart.slot.spread': "Spread of";
+    readonly 'label.chart.slot.candle': "One candle per";
+    readonly 'label.chart.slot.moves': "Moves of";
+    readonly 'label.chart.slot.shape': "One shape per";
+    readonly 'label.chart.slot.line': "One line per";
+    readonly 'label.chart.slot.axes': "Axes";
+    readonly 'label.chart.slot.levels': "Levels, outermost first";
+    readonly 'label.chart.slot.flow': "Flow, left to right";
+    readonly 'label.chart.slot.day': "Days";
+    readonly 'label.chart.slot.region': "Regions";
+    readonly 'label.chart.slot.map': "Map";
+    readonly 'label.chart.slot.streams': "One stream per";
+    readonly 'label.chart.axis-on': "Draw {name} as an axis";
+    readonly 'label.chart.gauge.min': "Scale starts at";
+    readonly 'label.chart.gauge.max': "Scale ends at";
+    readonly 'label.chart.gauge.auto': "Automatic";
+    readonly 'label.chart.compare-with': "Compared with";
+    readonly 'label.chart.target-value': "Target value";
+    readonly 'label.chart.slot.stage-order': "Stage order";
+    readonly 'label.chart.remove-stage': "Remove stage {name}";
+    readonly 'label.chart.compare-mode': "Comparison";
+    readonly 'label.chart.compare.delta': "Difference";
+    readonly 'label.chart.compare.percent': "Percent";
+    readonly 'label.chart.headline': "Big number";
+    readonly 'label.chart.headline.last': "Last period";
+    readonly 'label.chart.headline.whole': "All";
+    readonly 'label.chart.headline.last.hint': "The last period that has ended, against the one before; the comparison and the target are for that period.";
+    readonly 'label.chart.headline.whole.hint': "Every record in the range; the comparison and the target are for all of it.";
+    readonly 'label.chart.lower-is-better': "A fall is good";
+    readonly 'label.chart.lower-is-better.hint': "Colours a fall green and a rise red — for failures, latency and the like.";
+    readonly 'label.chart.legend': "Legend";
+    readonly 'label.chart.legend.auto': "Auto";
+    readonly 'label.chart.legend.top': "Top";
+    readonly 'label.chart.legend.bottom': "Bottom";
+    readonly 'label.chart.legend.right': "Right";
+    readonly 'label.chart.legend.none': "None";
+    readonly 'label.chart.labels': "Value labels";
+    readonly 'label.chart.labels.auto': "Auto";
+    readonly 'label.chart.labels.all': "Every value";
+    readonly 'label.chart.labels.none': "None";
+    readonly 'label.chart.labels.share': "Share only";
+    readonly 'label.chart.labels.value-share': "Value and share";
+    readonly 'label.chart.labels.auto.peaks': "{count} bars: only the highest and the lowest are labelled";
+    readonly 'label.chart.labels.auto.peaks.lines': "{count} bars: only the highest and the lowest are labelled; lines and areas are not";
+    readonly 'label.chart.labels.auto.bars': "Under {from} bars, every bar is labelled; from {from} on, only the highest and the lowest";
+    readonly 'label.chart.labels.auto.bars.lines': "Under {from} bars, every bar is labelled; from {from} on, only the highest and the lowest; lines and areas are not";
+    readonly 'label.chart.labels.auto.totals': "{count} stacks: each part is labelled, and only the highest and the lowest total";
+    readonly 'label.chart.labels.auto.totals.lines': "{count} stacks: each part is labelled, and only the highest and the lowest total; lines and areas are not";
+    readonly 'label.chart.labels.auto.stacks': "Each part is labelled; under {from} stacks every total, from {from} on only the highest and the lowest";
+    readonly 'label.chart.labels.auto.stacks.lines': "Each part is labelled; under {from} stacks every total, from {from} on only the highest and the lowest; lines and areas are not";
+    readonly 'label.chart.stacked': "Stacked";
+    readonly 'label.chart.stacked-alone': "Stacking needs two or more bar or area series";
+    readonly 'label.chart.percent-stack': "Stacked to 100%";
+    readonly 'label.chart.percent-stack.hint': "Each stack reads as shares of its total; the tooltip keeps the values";
+    readonly 'label.chart.horizontal': "Horizontal";
+    readonly 'label.chart.smooth': "Smooth lines";
+    readonly 'label.chart.missing': "Missing values";
+    readonly 'label.chart.missing.zero': "Zero";
+    readonly 'label.chart.missing.gap': "Leave a gap";
+    readonly 'label.chart.missing.zero.hint': "Zero where the group is known to have no records and the metric adds up (a count, a sum); a gap elsewhere";
+    readonly 'label.chart.missing.gap.hint': "A point with no rows is not drawn, and a line breaks there";
+    readonly 'label.chart.reference-lines': "Reference lines";
+    readonly 'label.chart.reference-row': "Reference line {index}";
+    readonly 'label.chart.add-reference-line': "Add reference line";
+    readonly 'label.chart.remove-reference-line': "Remove reference line";
+    readonly 'label.chart.reference-axis': "Axis of the reference line";
+    readonly 'label.chart.reference-label': "Caption";
+    readonly 'label.chart.reference-value': "Value of the reference line";
+    readonly 'label.chart.reference-kind': "Stands at";
+    readonly 'label.chart.reference-kind.value': "A number";
+    readonly 'label.chart.reference-kind.average': "The average";
+    readonly 'label.chart.reference-kind.median': "The median";
+    readonly 'label.chart.reference-metric': "Of the metric";
+    readonly 'label.chart.reference-bands': "Target bands";
+    readonly 'label.chart.reference-band-row': "Target band {index}";
+    readonly 'label.chart.add-reference-band': "Add target band";
+    readonly 'label.chart.remove-reference-band': "Remove target band";
+    readonly 'label.chart.band-from': "From";
+    readonly 'label.chart.band-to': "To";
+    readonly 'label.chart.band-order': "The band runs from the smaller number to the larger one.";
+    readonly 'label.chart.extremes': "Mark the highest and lowest points";
+    readonly 'label.chart.extremes.stacked': "A stacked segment stands at its stack’s height, so it is not marked.";
+    readonly 'label.chart.derived': "Computed lines";
+    readonly 'label.chart.derived.hint': "Computed from the rows on screen along the whole time axis, drawn dashed; no query is sent.";
+    readonly 'label.chart.derived.add.trend': "Trend line";
+    readonly 'label.chart.derived.add.moving-average': "Moving average";
+    readonly 'label.chart.derived.add.cumulative': "Running total";
+    readonly 'label.chart.derived.add.cumulative-share': "Running share";
+    readonly 'label.chart.derived.window': "Periods";
+    readonly 'label.chart.derived.window.hint': "Left empty: {count}.";
+    readonly 'label.chart.derived.metric': "Computed from";
+    readonly 'label.chart.derived.trend': "Trend";
+    readonly 'label.chart.derived.moving-average': "{window}-period moving average";
+    readonly 'label.chart.derived.cumulative': "Running total";
+    readonly 'label.chart.derived.cumulative-share': "Running share";
+    readonly 'label.chart.derived.computed': "{name} (computed)";
+    readonly 'label.chart.derived.of': "{name} · {series}";
+    readonly 'label.chart.statistic.average': "Average";
+    readonly 'label.chart.statistic.median': "Median";
+    readonly 'label.chart.statistic.caption': "{statistic} {value}";
+    readonly 'label.chart.extreme.high': "High";
+    readonly 'label.chart.extreme.low': "Low";
+    readonly 'label.chart.gap.note': "{what} is not drawn: {reason}";
+    readonly 'label.chart.gap.split': "a split draws a line per value, and computed lines are drawn on an unsplit chart only.";
+    readonly 'label.chart.gap.not-sorted': "along categories a running line reads only in its metric’s order: sort the result by it first.";
+    readonly 'label.chart.gap.not-time': "the horizontal axis is not time, and these lines are computed along time only.";
+    readonly 'label.chart.gap.narrowed': "“Keep only” dropped some groups, so the line would be incomplete.";
+    readonly 'label.chart.gap.cut-short': "the result shows only the first {limit} groups, so the line would be incomplete.";
+    readonly 'label.chart.gap.holes': "the time axis has gaps no one can put a number on, so the line would be wrong.";
+    readonly 'label.chart.gap.not-additive': "a running total holds only for a metric that adds up (a record count or a sum).";
+    readonly 'label.chart.gap.too-few': "there are too few points to compute it.";
+    readonly 'label.chart.gap.shares': "the chart draws shares of 100%, and a computed line of shares means nothing.";
+    readonly 'label.chart.gap.statistic-split': "a split draws a line per value, and an average or median line is drawn on an unsplit chart only.";
+    readonly 'label.chart.gap.none-measured': "there is no measured value to take it of.";
+    readonly 'label.chart.donut': "Donut";
+    readonly 'label.chart.max-slices': "Slices at most";
+    readonly 'label.chart.max-slices.hint': "The rest merge into “Other”. At most {count}, one colour each — and {count} when left empty.";
+    readonly 'label.chart.scale': "Colour scale";
+    readonly 'label.chart.scale.linear': "Linear";
+    readonly 'label.chart.scale.log': "Logarithmic";
+    readonly 'label.chart.scale.not-positive': "A log scale has no place for 0 or a negative number, and a cell here holds one: the cells are shaded linearly.";
+    readonly 'label.chart.cumulative': "Cumulative (reached at least this stage)";
+    readonly 'label.chart.format': "Number format";
+    readonly 'label.chart.format.auto': "Auto";
+    readonly 'label.chart.format.compact': "Compact";
+    readonly 'label.chart.format.percent': "Percent";
+    readonly 'label.chart.axis-title': "Axis title";
+    readonly 'label.chart.axis-title.none': "None — the legend names the series";
+    readonly 'label.chart.axis-min': "Minimum";
+    readonly 'label.chart.axis-max': "Maximum";
+    readonly 'label.chart.axis-scale': "Scale";
+    readonly 'label.chart.axis-scale.linear': "Linear";
+    readonly 'label.chart.axis-scale.log': "Logarithmic";
+    readonly 'label.chart.axis-scale.not-positive': "A log scale has no place for 0 or a negative number, and this axis holds one.";
+    readonly 'label.chart.axis.x': "Horizontal axis";
+    readonly 'label.chart.axis.y': "Vertical axis";
+    readonly 'label.chart.log-refused': "{axis} is drawn on a linear scale: it holds 0 or a negative number, which a log scale has no place for.";
+    readonly 'label.chart.crowded': "More than {slots} series, so colours repeat. A heatmap or the table reads them better.";
+    readonly 'label.analysis.grouping-of': "Dimension settings for {name}";
+    readonly 'label.analysis.card-menu': "More settings for {name}";
+    readonly 'label.analysis.condition-of': "Conditions for {name}";
+    readonly 'label.analysis.condition-title': "Only records where";
+    readonly 'label.analysis.condition-close': "Close the conditions";
+    readonly 'label.analysis.condition-remove': "Remove the condition, count every record";
+    readonly 'label.analysis.only-where': "Only where {conditions}";
+    readonly 'label.analysis.metric-where': "{metric} · {value}";
+    readonly 'label.analysis.metric-conditioned': "{metric} · conditioned";
+    readonly 'label.analysis.name-it': "Give it a display name";
+    readonly 'label.analysis.copy-with-condition': "Copy “{name}” with a condition";
+    readonly 'label.analysis.five-numbers': "Add the five numbers for a boxplot";
+    readonly 'label.analysis.ohlc': "Add the four numbers for a candlestick";
+    readonly 'label.analysis.rename': "Display name…";
+    readonly 'label.analysis.display-name': "Display name for {name}";
+    readonly 'label.analysis.missing-bucket': "Missing values as their own group";
+    readonly 'label.analysis.missing-group': "(empty)";
+    readonly 'label.analysis.dense': "Fill in empty periods";
+    readonly 'label.analysis.dense-alone': "Fill in empty periods (needs to be the only dimension)";
+    readonly 'label.analysis.dense-part': "List every value, even with no records";
+    readonly 'label.analysis.dense-part-alone': "List every value, even with no records (needs to be the only dimension)";
+    readonly 'label.analysis.remove-group': "Remove dimension {name}";
+    readonly 'label.analysis.function-of': "Summary for {name}";
+    readonly 'label.analysis.remove-metric': "Remove metric {name}";
+    readonly 'label.analysis.empty': "No groups match";
+    readonly 'label.analysis.empty-hint': "No record under the current conditions falls into a group.";
+    readonly 'label.analysis.empty-view': "This view has no records to group right now.";
+    readonly 'label.analysis.empty-none': "There are no records in the range to group";
+    readonly 'label.analysis.empty-clear': "Clear the conditions";
+    readonly 'label.analysis.empty-restore': "Back to the saved conditions";
+    readonly 'label.analysis.empty-edit': "Change the range";
+    readonly 'label.chart.type.bar': "bar";
+    readonly 'label.chart.type.line': "line";
+    readonly 'label.chart.type.area': "area";
+    readonly 'label.chart.type.combo': "combo";
+    readonly 'label.chart.type.pie': "pie";
+    readonly 'label.chart.type.heatmap': "heatmap";
+    readonly 'label.chart.type.scatter': "scatter";
+    readonly 'label.chart.type.funnel': "funnel";
+    readonly 'label.chart.type.metric': "metric";
+    readonly 'label.chart.type.waterfall': "waterfall";
+    readonly 'label.chart.type.treemap': "treemap";
+    readonly 'label.chart.type.boxplot': "boxplot";
+    readonly 'label.chart.type.candlestick': "candlestick";
+    readonly 'label.chart.type.gauge': "gauge";
+    readonly 'label.chart.type.radar': "radar";
+    readonly 'label.chart.type.parallel': "parallel coordinates";
+    readonly 'label.chart.type.sunburst': "sunburst";
+    readonly 'label.chart.type.tree': "tree";
+    readonly 'label.chart.type.sankey': "sankey";
+    readonly 'label.chart.type.calendar': "calendar";
+    readonly 'label.chart.type.themeRiver': "theme river";
+    readonly 'label.chart.type.map': "map";
+    readonly 'label.analysis.as-table': "The {type} chart cannot draw this result ({reason}); it shows as a table.";
+    readonly 'label.group.type.TERMS': "By value";
+    readonly 'label.group.type.HISTOGRAM': "By number range";
+    readonly 'label.group.type.DATE_HISTOGRAM': "By time unit";
+    readonly 'label.group.type.DATE_PART': "By cycle (weekday, hour…)";
+    readonly 'label.chart.other': "Other";
+    readonly 'label.chart.series.of-field': "{field}: {value}";
+    readonly 'label.chart.share-basis': "Shares of the groups shown";
+    readonly 'label.chart.waterfall.total-basis': "The total is of the groups shown";
+    readonly 'label.chart.waterfall.increase': "Increase";
+    readonly 'label.chart.waterfall.decrease': "Decrease";
+    readonly 'label.chart.treemap.omitted': "{count} groups not above zero are not drawn";
+    readonly 'label.chart.treemap.omitted-one': "1 group not above zero is not drawn";
+    readonly 'label.chart.boxplot.approximate': "Quartiles and median are approximate";
+    readonly 'label.chart.boxplot.omitted': "{count} groups without all five numbers are not drawn";
+    readonly 'label.chart.boxplot.omitted-one': "1 group without all five numbers is not drawn";
+    readonly 'label.chart.candlestick.omitted': "{count} periods without all four numbers are not drawn";
+    readonly 'label.chart.candlestick.omitted-one': "1 period without all four numbers is not drawn";
+    readonly 'label.chart.candlestick.rise': "Closed higher";
+    readonly 'label.chart.candlestick.fall': "Closed lower";
+    readonly 'label.chart.candlestick.flat': "Closed where it opened";
+    readonly 'label.chart.radar.omitted': "{count} more groups are only in the table";
+    readonly 'label.chart.radar.omitted-one': "1 more group is only in the table";
+    readonly 'label.chart.parallel.omitted': "{count} groups missing a number are not drawn";
+    readonly 'label.chart.parallel.omitted-one': "1 group missing a number is not drawn";
+    readonly 'label.chart.gauge.above': "The value is past the end of the scale";
+    readonly 'label.chart.gauge.below': "The value is below the start of the scale";
+    readonly 'label.chart.gauge.reached': "{share} of the target";
+    readonly 'label.chart.filled.YEAR': "{value} (no records this year)";
+    readonly 'label.chart.filled.QUARTER': "{value} (no records this quarter)";
+    readonly 'label.chart.filled.MONTH': "{value} (no records this month)";
+    readonly 'label.chart.filled.WEEK': "{value} (no records this week)";
+    readonly 'label.chart.filled.DAY': "{value} (no records this day)";
+    readonly 'label.chart.filled.HOUR': "{value} (no records this hour)";
+    readonly 'label.chart.filled.MINUTE': "{value} (no records this minute)";
+    readonly 'label.chart.filled.SECOND': "{value} (no records this second)";
+    readonly 'label.chart.filled.group': "{value} (no records in this group)";
+    readonly 'label.chart.legend.more': "{count} more";
+    readonly 'label.chart.legend.less': "Show less";
+    readonly 'label.chart.legend.toggle': "Series shown — press one to hide or show it";
+    readonly 'label.chart.total': "Total";
+    readonly 'label.chart.trend': "Trend";
+    readonly 'label.chart.figure': "{type}: {measures} by {category}";
+    readonly 'label.chart.figure.plain': "{type}: {measures}";
+    readonly 'label.chart.sparkline': "{name}, over time";
+    readonly 'label.chart.reading': "{name}, as a table";
+    readonly 'label.chart.sentence': "{count} groups; highest {high}, {highValue}; lowest {low}, {lowValue}.";
+    readonly 'label.chart.sentence-one': "1 group; highest {high}, {highValue}; lowest {low}, {lowValue}.";
+    readonly 'label.chart.sentence.time': "{count} periods from {first} to {last}, {trend}; highest {high}, {highValue}; lowest {low}, {lowValue}.";
+    readonly 'label.chart.sentence.up': "rising overall";
+    readonly 'label.chart.sentence.down': "falling overall";
+    readonly 'label.chart.sentence.flat': "about level overall";
+    readonly 'label.chart.ongoing': "{period} (in progress)";
+    readonly 'label.chart.ongoing.band': "In progress";
+    readonly 'label.chart.sentence.unfinished': " {period} is not over yet and is not counted.";
+    readonly 'label.chart.sentence.trend-of': "{measure} {trend}";
+    readonly 'label.chart.sentence.other-axis': " On the other axis, {measures}: highest {high}, {highValue}; lowest {low}, {lowValue}.";
+    readonly 'label.chart.sentence.scatter': "{count} points; {x} from {xLow} to {xHigh}, {y} from {yLow} to {yHigh}.";
+    readonly 'label.chart.sentence.scatter-one': "1 point; {x} from {xLow} to {xHigh}, {y} from {yLow} to {yHigh}.";
+    readonly 'label.chart.sentence.boxplot': "{count} groups; highest median {high}, {highValue}; lowest median {low}, {lowValue}.";
+    readonly 'label.chart.sentence.boxplot-one': "1 group; highest median {high}, {highValue}; lowest median {low}, {lowValue}.";
+    readonly 'label.chart.sentence.gauge': "{value} on a scale from {min} to {max}.";
+    readonly 'label.chart.sentence.funnel': "{count} stages from {first}, {firstValue}, to {last}, {lastValue}; {overall} overall.";
+    readonly 'label.chart.sentence.funnel-drop': " The largest drop is from {from} to {to}: {drop} ({rate}).";
+    readonly 'label.chart.sentence.candlestick': "{count} periods, from {first} to {last}; opened at {open}, closed at {close}; highest {high}, lowest {low}.";
+    readonly 'label.chart.sentence.gauge-target': "{value}, {share} of the target {target}.";
+    readonly 'label.chart.sentence.profile-metric': "{metric}: highest {high}, {highValue}; lowest {low}, {lowValue}";
+    readonly 'label.chart.sentence.profile-join': ". ";
+    readonly 'label.chart.sentence.profile-readings': " {readings}.";
+    readonly 'label.chart.sentence.profiles': "{count} groups across {metrics} metrics.";
+    readonly 'label.chart.sentence.sankey': "{count} flows; the largest {high}, {highValue}.";
+    readonly 'label.chart.sentence.sankey-one': "1 flow; the largest {high}, {highValue}.";
+    readonly 'label.chart.sentence.themeRiver': "{streams} streams over {count} periods from {first} to {last}, {trend}.";
+    readonly 'label.chart.map.missing': "No map is available to draw on";
+    readonly 'label.chart.map.failed': "The map could not be loaded";
+    readonly 'label.chart.map.unplaced': "{count} regions are not on this map";
+    readonly 'label.chart.map.unplaced-one': "1 region is not on this map";
+    readonly 'label.chart.map.omitted': "{count} regions without a number are not drawn";
+    readonly 'label.chart.map.omitted-one': "1 region without a number is not drawn";
+    readonly 'label.chart.themeRiver.uncertain': "{count} points have no row and are drawn as 0; the rows may be cut short";
+    readonly 'label.chart.themeRiver.uncertain-one': "1 point has no row and is drawn as 0; the rows may be cut short";
+    readonly 'label.chart.column.category': "Category";
+    readonly 'label.chart.column.value': "Value";
+    readonly 'label.chart.column.direction': "Direction";
+    readonly 'label.chart.column.x': "X";
+    readonly 'label.chart.column.y': "Y";
+    readonly 'label.chart.column.stage': "Stage";
+    readonly 'label.chart.column.conversion.previous': "Conversion from previous stage";
+    readonly 'label.chart.column.conversion.first': "Conversion from first stage";
+    readonly 'label.chart.column.drop': "Drop from previous stage";
+    readonly 'label.chart.funnel.key': "Percentages are of the first stage; between stages, the drop from the one before";
+    readonly 'label.chart.funnel.overall': "{share} overall ({last} / {first})";
+    readonly 'label.chart.funnel.largest-drop': "Largest drop";
+    readonly 'label.chart.column.cumulative': "Cumulative: reached at least this stage";
+    readonly 'label.chart.column.compare': "Compared with";
+    readonly 'label.chart.column.target': "Target";
+    readonly 'label.chart.column.change': "Change";
+    readonly 'label.chart.column.running': "Running total";
+    readonly 'label.chart.column.share': "Share";
+    readonly 'label.chart.column.from': "From";
+    readonly 'label.chart.column.to': "To";
+    readonly 'label.chart.column.scale-min': "Scale start";
+    readonly 'label.chart.column.scale-max': "Scale end";
+    readonly 'label.chart.column.reached': "Of the target";
+    readonly 'label.chart.target': "Toward target";
+    readonly 'label.chart.target.reached': "{value} of {target}";
+    readonly 'label.chart.period.week': "Week of {start}";
+    readonly 'label.chart.period.so-far': "{period} so far";
+    readonly 'label.chart.period.whole': "All in range";
+    readonly 'label.chart.period.skipped': "{period} is not over yet and is not counted";
+    readonly 'label.chart.change.against': "vs previous period";
+    readonly 'label.chart.change.against.YEAR': "vs the year before";
+    readonly 'label.chart.change.against.QUARTER': "vs the quarter before";
+    readonly 'label.chart.change.against.MONTH': "vs the month before";
+    readonly 'label.chart.change.against.WEEK': "vs the week before";
+    readonly 'label.chart.change.against.DAY': "vs the day before";
+    readonly 'label.chart.change.against.HOUR': "vs the hour before";
+    readonly 'label.chart.change.against.MINUTE': "vs the minute before";
+    readonly 'label.chart.change.against.SECOND': "vs the second before";
+    readonly 'label.chart.compare.against': "vs {metric}";
+    readonly 'label.chart.compare.unmatched': "The span of {metric} does not match the dates picked; not compared";
+    readonly 'label.chart.change.points': "{amount} pp";
+    readonly 'label.chart.change.none': "No previous period to compare with";
+    readonly 'label.chart.change.unknown': "No number in the previous period to compare with";
+    readonly 'label.chart.change.unmatched': "The dates picked cover this period and the one before unequally; not compared";
+    readonly 'label.chart.period.range.in-year': "{start} – {end}, {year}";
+    readonly 'label.chart.period.range': "{from} – {to}";
+    readonly 'label.chart.period.cut': "More than {limit} periods: the latest is not among them, so there is no number to show. Narrow the dates or read by a coarser period.";
+    readonly 'analysis.alias.duplicate': "The display name {alias} is used twice.";
+    readonly 'analysis.alias.invalid': "{alias} is not a usable display name.";
+    readonly 'analysis.alias.not-a-segment': "{alias} cannot contain a dot.";
+    readonly 'analysis.alias.reserved': "{alias} uses a reserved prefix.";
+    readonly 'analysis.any.undeclared': "{field} cannot be shown as a sample value.";
+    readonly 'analysis.capability.missing': "{definition} does not offer an analysis view any more.";
+    readonly 'analysis.column.duplicate': "This result lists {alias} twice.";
+    readonly 'analysis.column.unknown-alias': "There is no {alias} in this result.";
+    readonly 'analysis.config.malformed': "This analysis has no usable shape.";
+    readonly 'analysis.constant.not-finite': "A constant must be a finite number.";
+    readonly 'analysis.count.undeclared': "This dataset does not offer a record count.";
+    readonly 'analysis.derived.unknown-metric': "The derived metric refers to {metric}, which is not declared before it.";
+    readonly 'analysis.derived.moment-operand': "{metric} is a point in time and cannot be calculated with.";
+    readonly 'analysis.derived.format-invalid': "A calculated metric reads as a number, a percent or money.";
+    readonly 'analysis.derived.decimals': "Decimals are a whole number from 0 to {max}.";
+    readonly 'analysis.derived.currency-invalid': "That is not a currency code.";
+    readonly 'analysis.derived.currency-unknown': "Its operands are in no one currency: choose the currency it is in.";
+    readonly 'analysis.distinctCount.undeclared': "{field} does not offer distinct counts.";
+    readonly 'analysis.element.out-of-chain': "The expansion of {path} belongs to another level of the chain.";
+    readonly 'analysis.element.undeclared': "The expansion of {path} is not available.";
+    readonly 'analysis.elementFilter.empty': "This filter has no conditions, so every item is expanded.";
+    readonly 'analysis.elementFilter.incomplete': "Give {field} a value, or every item is expanded.";
+    readonly 'analysis.elementFilter.search': "A search cannot decide which items are expanded: take {field} out of this condition.";
+    readonly 'analysis.elements.too-many': "Too many expansions for this dataset.";
+    readonly 'analysis.expression.divide-by-zero': "This expression divides by zero.";
+    readonly 'analysis.expression.date-operand': "{field} is a date and cannot be calculated with.";
+    readonly 'analysis.expression.malformed': "This metric has no usable expression.";
+    readonly 'analysis.expression.operand-unsupported': "The source cannot calculate with {field}.";
+    readonly 'analysis.metric.filter-field-unsupported': "The source cannot use {field} in a metric's own condition.";
+    readonly 'analysis.expression.too-deep': "The expression nests deeper than {max} levels.";
+    readonly 'analysis.expression.too-many-nodes': "The expressions exceed {max} entries.";
+    readonly 'analysis.expressions.undeclared': "This dataset does not offer computed expressions.";
+    readonly 'analysis.field.outside-scope': "The field {field} sits outside the expanded scope.";
+    readonly 'analysis.field.unknown': "The field {field} is not available here.";
+    readonly 'analysis.function.unsupported': "{field} cannot be summarised as {fn}.";
+    readonly 'analysis.group.blank-missing-key': "The placeholder for missing values is empty.";
+    readonly 'analysis.group.blank-time-zone': "The time zone is empty.";
+    readonly 'analysis.group.dense-unsupported': "The source cannot fill the gaps of a time dimension.";
+    readonly 'analysis.group.dense-not-alone': "A gap-filling time dimension must be the only dimension.";
+    readonly 'analysis.group.interval-not-positive': "A number range must be wider than zero.";
+    readonly 'analysis.group.missing-key-unsupported': "{field} cannot hold a bucket for missing values; only single-valued text fields can.";
+    readonly 'analysis.group.unit-unsupported': "This dimension cannot group this way: {unit}.";
+    readonly 'analysis.first-last.undeclared': "{field} offers no opening or closing value.";
+    readonly 'analysis.first-last.order-by-required': "Inside expanded entries, an opening or closing value needs a time to order the entries by.";
+    readonly 'analysis.date-diff.unit-unsupported': "A time between two moments cannot be measured in {unit} here.";
+    readonly 'analysis.date-diff.not-time': "{field} holds no time a duration could run from or to.";
+    readonly 'analysis.group.part-unsupported': "This dimension cannot group this way: {part}.";
+    readonly 'analysis.label.blank': "The display name is empty.";
+    readonly 'analysis.group.unsupported': "{field} cannot be grouped this way: {type}.";
+    readonly 'analysis.groups.too-many': "Too many dimensions for this dataset.";
+    readonly 'analysis.having.malformed': "This result filter has no usable shape.";
+    readonly 'analysis.having.requires-group': "Filtering the result needs at least one dimension.";
+    readonly 'analysis.having.too-deep': "The result filter nests deeper than {max} levels.";
+    readonly 'analysis.having.too-many-nodes': "The result filter exceeds {max} entries.";
+    readonly 'analysis.having.undeclared': "This dataset does not offer filtering the result.";
+    readonly 'analysis.having.metric-unsupported': "The source cannot keep groups by {metric}.";
+    readonly 'analysis.having.unknown-metric': "The filter refers to {metric}, which is not a usable metric.";
+    readonly 'analysis.limit.out-of-range': "Top N groups must be a whole number from 1 to {max}.";
+    readonly 'analysis.metric.type-unknown': "The metric type {type} is not available.";
+    readonly 'analysis.metricFilter.empty': "This filter has no conditions, so the metric covers every record.";
+    readonly 'analysis.metricFilter.incomplete': "Give {field} a value, or the metric covers every record.";
+    readonly 'analysis.metricFilter.not-scalar': "{field} has no single value for a metric filter to test.";
+    readonly 'analysis.metrics.empty': "An analysis needs at least one metric.";
+    readonly 'analysis.metrics.too-many': "Too many metrics for this dataset.";
+    readonly 'analysis.percentile.out-of-range': "A percentile must be between 0 and 100, exclusive.";
+    readonly 'analysis.percentile.undeclared': "{field} does not offer percentiles.";
+    readonly 'analysis.metric.out-of-reach': "The span of {metric} lies outside the dates picked, so it does not apply and is left empty.";
+    readonly 'analysis.result.more-groups': "Showing the first {limit} groups; there are more.";
+    readonly 'analysis.result.at-limit': "Showing the first {limit} groups; there may be more.";
+    readonly 'analysis.result.mixed-currency': "{metric}: some groups hold records in several currencies, so their amounts are not added up; group by {field} to see each currency.";
+    readonly 'analysis.metric.currency-unchecked': "{metric} is money in each record’s own currency, which the source cannot check, so its totals may add several currencies; group by {field} to see each currency.";
+    readonly 'analysis.split.whole-failed': "Could not fold the smaller series into “Other”, so colours repeat: {reason}";
+    readonly 'analysis.sort.duplicate': "The sort already orders by {alias}.";
+    readonly 'analysis.sort.metric-unsupported': "The source orders groups by their dimensions only, not by {alias}.";
+    readonly 'analysis.sort.requires-group': "Sorting needs at least one dimension.";
+    readonly 'analysis.sort.too-many': "A result sorts by at most {max} dimensions and metrics.";
+    readonly 'analysis.sort.unknown-alias': "The sort orders by {alias}, which this result does not have.";
+    readonly 'chart.as-table': "The chosen chart cannot draw this result; it shows as a table.";
+    readonly 'chart.cartesian.percent-not-additive': "A 100% stack needs metrics that add up (a record count or a sum), not {metric}.";
+    readonly 'chart.combo.series-type-missing': "Every series of a combo chart needs its own type.";
+    readonly 'chart.colors.invalid': "This is not a colour the chart can paint with.";
+    readonly 'chart.colors.malformed': "The pinned chart colours must be listed one per series or category.";
+    readonly 'chart.family.missing': "The {type} chart has no {family} settings yet.";
+    readonly 'chart.funnel.duplicate-stage': "A funnel stage is listed twice.";
+    readonly 'chart.funnel.metrics-need-no-group': "A funnel staged by metrics can carry no dimension.";
+    readonly 'chart.funnel.too-few-stages': "A funnel needs at least two stages.";
+    readonly 'chart.funnel.not-additive': "A funnel needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.funnel.stages-need-category': "A funnel’s stages are the values of a category, not dates or number ranges.";
+    readonly 'chart.group.unconsumed': "The chart does not use the dimension {alias}.";
+    readonly 'chart.group.unknown': "The chart uses a dimension this analysis does not have.";
+    readonly 'chart.heatmap.same-axes': "A heatmap needs two different axes.";
+    readonly 'chart.treemap.not-additive': "A treemap’s tiles are parts of a whole, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.treemap.same-levels': "A treemap needs two different levels.";
+    readonly 'chart.boxplot.not-five-numbers': "A boxplot needs one field’s minimum, three rising percentiles and maximum, under one condition.";
+    readonly 'chart.candlestick.needs-date': "A candlestick runs along a date dimension.";
+    readonly 'chart.candlestick.not-ohlc': "A candlestick needs one field’s opening value, maximum, minimum and closing value, under one condition.";
+    readonly 'chart.gauge.needs-no-group': "A gauge can carry no dimension.";
+    readonly 'chart.gauge.not-a-number': "This needs a number.";
+    readonly 'chart.gauge.empty-scale': "The scale must end above where it starts.";
+    readonly 'chart.radar.too-few-metrics': "A radar needs three metrics or more.";
+    readonly 'chart.radar.duplicate-metric': "A radar lists one metric twice.";
+    readonly 'chart.sunburst.too-few-levels': "A sunburst needs two dimensions or more.";
+    readonly 'chart.sunburst.too-many-levels': "A sunburst draws at most four dimensions.";
+    readonly 'chart.sunburst.same-levels': "A sunburst lists one dimension twice.";
+    readonly 'chart.sunburst.not-additive': "A sunburst’s parts add up to their parent, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.tree.too-few-levels': "A tree needs two dimensions or more.";
+    readonly 'chart.tree.too-many-levels': "A tree draws at most four dimensions.";
+    readonly 'chart.tree.same-levels': "A tree lists one dimension twice.";
+    readonly 'chart.tree.not-additive': "A tree’s parts add up to their parent, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.sankey.too-few-levels': "A sankey needs two dimensions or more.";
+    readonly 'chart.sankey.too-many-levels': "A sankey draws at most four dimensions.";
+    readonly 'chart.sankey.same-levels': "A sankey lists one dimension twice.";
+    readonly 'chart.sankey.not-additive': "A sankey’s bands add up to what flows through, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.map.needs-region': "A map’s regions are the values of a dimension, not ranges or dates.";
+    readonly 'chart.map.name-invalid': "The map must be named.";
+    readonly 'chart.calendar.needs-day': "A calendar lays out days: its dimension must be a date by day.";
+    readonly 'chart.themeRiver.needs-date': "A theme river runs along a date dimension.";
+    readonly 'chart.themeRiver.same-axes': "A theme river needs two different dimensions.";
+    readonly 'chart.themeRiver.not-additive': "A theme river stacks its streams, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.parallel.too-few-metrics': "Parallel coordinates need three metrics or more.";
+    readonly 'chart.parallel.duplicate-metric': "Parallel coordinates list one metric twice.";
+    readonly 'chart.waterfall.not-additive': "A waterfall adds up its steps, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.metric.needs-no-group': "A metric card can carry no dimension.";
+    readonly 'chart.metric.trend-alias-mismatch': "The trend must use the {alias} dimension.";
+    readonly 'chart.metric.trend-needs-one-date-group': "A trend needs exactly one time dimension.";
+    readonly 'chart.metric.trend-not-additive': "A trend headline needs a metric that adds up, or one calculated from such metrics — not {metric}.";
+    readonly 'chart.metric.unknown': "The chart uses a metric this analysis does not have.";
+    readonly 'chart.metric.moment': "{alias} is a point in time; a chart does not draw or compare it.";
+    readonly 'chart.pie.not-additive': "A pie’s slices are shares of a whole, so it needs a metric that adds up (a record count or a sum), not {metric}.";
+    readonly 'chart.axis.scale-unknown': "This axis scale is not available.";
+    readonly 'chart.pie.maxSlices-too-small': "Keep at least two slices.";
+    readonly 'chart.referenceLine.empty-axis': "A reference line needs a series on its axis.";
+    readonly 'chart.referenceLine.value-missing': "A reference line stands at a number or at a statistic.";
+    readonly 'chart.referenceLine.statistic-unknown': "This statistic is not available.";
+    readonly 'chart.referenceLine.metric-not-drawn': "The reference line is taken of {metric}, which is not drawn on its axis.";
+    readonly 'chart.referenceBand.order': "A target band runs from a smaller number to a larger one.";
+    readonly 'chart.derived.kind-unknown': "This computed line is not available.";
+    readonly 'chart.derived.metric-not-drawn': "The computed line follows {metric}, which the chart does not draw.";
+    readonly 'chart.derived.window': "A moving average runs over 2 to {max} periods.";
+    readonly 'chart.scatter.same-metrics': "A scatter plot needs two different metrics.";
+    readonly 'chart.splitBy.needs-one-series': "A split chart shows exactly one metric.";
+    readonly 'chart.splitBy.same-as-x': "The split cannot repeat the horizontal axis.";
+    readonly 'chart.type.unknown': "This chart type is not available.";
+    readonly 'label.manage.open': "Manage views";
+    readonly 'label.manage.heading': "Manage views";
+    readonly 'label.manage.description': "Rename, reorder and delete views, and choose which one opens first.";
+    readonly 'label.manage.default': "Default";
+    readonly 'label.manage.view-group': "Actions for “{title}”";
+    readonly 'label.manage.set-default': "Open this one first";
+    readonly 'label.manage.unset-default': "Stop opening this one first";
+    readonly 'label.manage.drag': "Reorder {title}";
+    readonly 'label.manage.moved': "{title} moved to position {index} of {total}";
+    readonly 'label.manage.picked': "{title} picked up";
+    readonly 'label.manage.cancelled': "Move cancelled; {title} stayed where it was";
+    readonly 'label.manage.rename': "Rename";
+    readonly 'label.manage.rename-of': "Rename {title}";
+    readonly 'label.manage.rename-confirm': "Save the title";
+    readonly 'label.manage.rename-cancel': "Keep the title";
+    readonly 'label.manage.delete': "Delete";
+    readonly 'label.manage.share': "Make shared";
+    readonly 'label.manage.make-personal': "Make personal";
+    readonly 'label.manage.shared': "{title} is now shared";
+    readonly 'label.manage.made-personal': "{title} is now personal";
+    readonly 'label.manage.publish': "Publish as a system view";
+    readonly 'label.manage.published': "{title} is published as a system view";
+    readonly 'label.manage.resubmit': "Apply again";
+    readonly 'label.manage.reload': "Reload list";
+    readonly 'label.kind.record': "Record view";
+    readonly 'label.kind.analysis': "Analysis view";
+    readonly 'label.kind.dashboard': "Dashboard";
+    readonly 'label.view.list': "Views";
+    readonly 'label.view.list-failed': "The list could not be loaded.";
+    readonly 'label.view.none-hint': "Make one to start looking at the data.";
+    readonly 'label.view.new': "New view";
+    readonly 'label.view.new-title': "Untitled view";
+    readonly 'label.view.unopenable': "This view could not be opened";
+    readonly 'label.view.open-default': "Open the default view";
+    readonly 'label.view.open-retry': "Try again";
+    readonly 'label.view.needs-fixing': "This view needs fixing before it runs";
+    readonly 'label.view.conditions-to-fix': "Fix its conditions before this view runs ({count})";
+    readonly 'label.view.show-conditions': "Show conditions";
+    readonly 'label.view.unavailable': "This view uses what its data source no longer offers, and waits until it is removed";
+    readonly 'label.view.remove-unavailable': "Remove unavailable conditions";
+    readonly 'label.view.warnings-count': "{count} things worth noting";
+    readonly 'label.view.warnings-count-one': "1 thing worth noting";
+    readonly 'label.view.none': "No view yet";
+    readonly 'label.origin.back': "Back to {title}";
+    readonly 'label.origin.region': "Opened from another view";
+    readonly 'label.origin.board-region': "Opened from a dashboard";
+    readonly 'label.drill.menu': "This group";
+    readonly 'label.drill.records': "See these records";
+    readonly 'label.drill.gap.nested-elements': "Expanded more than one level deep: a condition on the records matches the first level only.";
+    readonly 'label.drill.split': "Split this group by…";
+    readonly 'label.drill.focus': "Only this group";
+    readonly 'label.drill.menu-span': "This period";
+    readonly 'label.drill.split-span': "Split this period by…";
+    readonly 'label.drill.focus-span': "Only this period";
+    readonly 'label.drill.set-filter': "Set “{filter}” to this period";
+    readonly 'label.drill.spanned': "Selected {group}. Follow-up menu open.";
+    readonly 'label.drill.span-hint': "Hold Shift and pick a second row to follow up on the period between the two.";
+    readonly 'label.drill.tap-again': "Tap again to follow up";
+    readonly 'label.drill.press-hint': "Click to follow up";
+    readonly 'label.drill.press-brush-hint': "Click to follow up · drag to select a span";
+    readonly 'label.drill.titled': "{subject} · {group}";
+    readonly 'runtime.kind.not-declared': "{definition} does not offer a {kind} view.";
+    readonly 'runtime.source.unresolved': "No source is registered for {source}.";
+    readonly 'runtime.options.unresolved': "No candidate source is configured for {source}.";
+    readonly 'runtime.query.failed': "Could not load the data: {reason}";
+    readonly 'runtime.query.unreachable': "Could not load the data: the server could not be reached.";
+    readonly 'runtime.query.forbidden': "You do not have permission to view this data.";
+    readonly 'runtime.query.failed.invalid_json': "The service could not read the query this view sent: {reason}";
+    readonly 'runtime.query.failed.body_not_object': "The service could not read the query this view sent: {reason}";
+    readonly 'runtime.query.failed.empty_body': "The service received an empty query: {reason}";
+    readonly 'runtime.query.failed.unknown_property': "The service does not understand part of this query; it may be older than this view engine: {reason}";
+    readonly 'runtime.query.failed.unknown_type': "The service does not know an operator or metric this view uses; it may be older than this view engine: {reason}";
+    readonly 'runtime.query.failed.unknown_value': "The service does not know a value this view sent: {reason}";
+    readonly 'runtime.query.failed.invalid_value': "A value in this query is missing or of the wrong kind: {reason}";
+    readonly 'runtime.query.failed.invalid_request': "The service refused the query: {reason}";
+    readonly 'runtime.query.failed.unknown_field': "The service does not know the field {field}. The view may be ahead of the data; remove the condition, column or group on it.";
+    readonly 'runtime.query.failed.unsupported_capability': "{field} cannot be used this way on this data: {reason}";
+    readonly 'runtime.query.failed.element_scope_required': "{field} can only be filtered inside its list, with a condition on the list's elements.";
+    readonly 'runtime.query.failed.value_mismatch': "A value is not one {field} can hold.";
+    readonly 'runtime.query.failed.not_collection': "{field} is not a list, so it cannot be checked for being empty.";
+    readonly 'runtime.query.failed.not_single_string': "{field} is not a single text value, so it cannot be checked for being empty.";
+    readonly 'runtime.query.failed.model_search_unsupported': "This data does not support search.";
+    readonly 'runtime.query.failed.cursor_not_allowed': "{field} cannot be used to page through this data.";
+    readonly 'runtime.query.failed.protected_aggregation': "{field} is protected and cannot be summarised.";
+    readonly 'runtime.query.failed.protected_comparison': "{field} is protected and cannot be used to filter, sort or search.";
+    readonly 'runtime.query.failed.missing_key_requires_string': "Only a single text field can group its missing values; {field} is not one.";
+    readonly 'runtime.query.failed.any_requires_single_value': "“Any value” needs a field that holds a single value.";
+    readonly 'runtime.query.failed.incomplete_projection': "The service cannot return whole records here; choose the columns to show.";
+    readonly 'runtime.query.failed.metric_filter_search': "A metric's own condition cannot use search.";
+    readonly 'runtime.query.failed.metric_filter_element_match': "A metric's own condition cannot match list elements.";
+    readonly 'runtime.query.failed.metric_filter_array_field': "A metric's own condition cannot use the list field {field}.";
+    readonly 'runtime.query.failed.cursor_sort_duplicate': "The sort names {field} twice; keep it once.";
+    readonly 'runtime.query.failed.cursor_sort_too_many': "The sort has too many fields to page through this data; remove some.";
+    readonly 'runtime.query.failed.not_projectable': "{field} cannot be shown as a column of this data.";
+    readonly 'runtime.query.failed.event_projection_type_required': "An event's payload cannot be shown without its type; keep the event type column.";
+    readonly 'runtime.query.failed.temporal_representation_required': "{field} is not stored as a known date or time, so a relative time cannot be asked of it.";
+    readonly 'runtime.query.failed.temporal_configuration_conflict': "The relative time on {field} does not agree with how the field keeps its time: {reason}";
+    readonly 'runtime.query.failed.parallel_array_sort': "{field} and another list field in the sort cannot be sorted by together; keep one of them.";
+    readonly 'runtime.query.failed.array_equality': "{field} cannot be compared with a whole list here; match its items instead.";
+    readonly 'runtime.query.failed.first_last_requires_single_value': "“First value” and “Last value” need a field that holds a single value; {field} may hold several.";
+    readonly 'runtime.query.failed.first_last_requires_order_by': "“First value” and “Last value” of {field} need a field to order by here: this data has no event time in that place.";
+    readonly 'runtime.query.failed.invalid_cursor': "This page can no longer be continued; start again from the first page.";
+    readonly 'runtime.query.failed.size_out_of_range': "The service limits how many rows one request may read: {reason}";
+    readonly 'runtime.query.failed.filter_too_large': "The conditions are more than the service accepts in one query: {reason}";
+    readonly 'runtime.query.failed.expensive_operator_disabled': "The service does not allow this costly query here: {reason}";
+    readonly 'runtime.query.failed.count_requires_filter': "Add a condition first: the service will not count every record.";
+    readonly 'runtime.query.failed.residual_groups_exceeded': "This summary has too many groups for the service to filter or sort by a metric; narrow the data first.";
+    readonly 'runtime.query.failed.explicit_entry_required': "The query named no entry to run against: {reason}";
+    readonly 'runtime.query.failed.temporal_aggregation_unsupported': "{field} does not store its time as a date or a timestamp, so it cannot be grouped or measured by time.";
+    readonly 'runtime.query.failed.sort_too_many': "The sort has too many fields; remove some.";
+    readonly 'runtime.query.failed.sort_field_duplicate': "{field} is sorted by twice; keep it once.";
+    readonly 'runtime.query.failed.identity_undefined': "This data defines no record identity, so it cannot be paged through or picked by id.";
+    readonly 'runtime.query.failed.storage_unsupported': "The service's storage cannot run this: {reason}";
+    readonly 'record.detail.failed': "The whole record could not be read: {reason}";
+    readonly 'runtime.query.queue-full': "Too many queries at once; try again in a moment.";
+    readonly 'runtime.query.too-many-nodes': "These conditions make a query of {count} parts; the source takes at most {max}. Remove some conditions.";
+    readonly 'runtime.query.too-many-values': "One condition lists {count} values; the source takes at most {max} in one condition.";
+    readonly 'runtime.summary.page-only': "The totals query failed, so the summary adds up only the rows on this page.";
+    readonly 'view.abandon.failed': "That write could not be set aside.";
+    readonly 'view.change.notify-failed': "A listener on view changes failed: {reason}. The list may be a revision behind.";
+    readonly 'view.config.invalid': "Fix what this view reports before saving it.";
+    readonly 'view.create.forbidden': "You may not create views here.";
+    readonly 'view.definition.invalid': "The {id} definition has {issues} problem(s) and cannot be opened.";
+    readonly 'view.definition.not-found': "No definition named {id}.";
+    readonly 'view.changeAudience.failed': "Who this view is for could not be changed.";
+    readonly 'view.changeAudience.forbidden': "You may not change who this view is for; save a copy of your own instead.";
+    readonly 'view.changeAudience.unsupported': "This view store cannot move a view between personal and shared.";
+    readonly 'view.changeAudience.invalid': "Who this view is for could not be changed: {reason}";
+    readonly 'view.changeAudience.invalid.shared-boards': "This view stays shared: shared dashboards show it ({boards}).";
+    readonly 'view.changeAudience.invalid.shared-boards-one': "This view stays shared: a shared dashboard shows it ({boards}).";
+    readonly 'view.delete.failed': "This view could not be deleted.";
+    readonly 'view.delete.forbidden': "You may not delete this view; ask whoever owns it to remove it.";
+    readonly 'view.list.failed': "The list of views could not be loaded.";
+    readonly 'view.list.reserved-id': "The stored view {id} uses a reserved id and was skipped.";
+    readonly 'view.open.failed': "This view could not be opened.";
+    readonly 'view.open.not-found': "No view named {id}.";
+    readonly 'view.open.wrong-kind': "This view is of another kind ({kind}), so this page cannot show it.";
+    readonly 'view.open.other-definition': "This view belongs to another page, so this page cannot show it.";
+    readonly 'view.preferences.default-forbidden': "You may not set the default view.";
+    readonly 'view.preferences.failed': "Your view preferences could not be saved.";
+    readonly 'view.preferences.load-failed': "Your view preferences could not be loaded; the views are in the server’s order.";
+    readonly 'view.preferences.reorder-forbidden': "You may not reorder views.";
+    readonly 'view.rename.failed': "This view could not be renamed.";
+    readonly 'view.rename.forbidden': "You may not rename this view; save a copy of your own instead.";
+    readonly 'view.resolve.failed': "That conflict could not be resolved.";
+    readonly 'view.retry.failed': "That write could not be retried.";
+    readonly 'view.runtime.not-owned': "This view is not open here any more.";
+    readonly 'view.save-as.failed': "This view could not be saved as a copy.";
+    readonly 'view.publish.failed': "This view could not be published as a system view.";
+    readonly 'view.publish.forbidden': "You may not publish system views; ask an administrator.";
+    readonly 'view.save.failed': "This view could not be saved.";
+    readonly 'view.save.forbidden': "You may not save changes to this view; save a copy of your own instead.";
+    readonly 'view.system.read-only': "A built-in view cannot be changed ({action}).";
+    readonly 'view.title.empty': "A view needs a title.";
+    readonly 'view.title.too-long': "A view’s title can be at most {max} characters.";
+    readonly 'view.config.too-large': "This view is too large to save: {size} KB, where the store keeps at most {max} KB.";
+    readonly 'view.field.deprecated': "This view uses {field}, which its data source deprecates.";
+    readonly 'view.field.deprecated-because': "This view uses {field}, which its data source deprecates: {reason}";
+    readonly 'view.write.conflict-unreadable': "Someone else saved first, and their version could not be read.";
+    readonly 'view.write.not-a-conflict': "That write is {kind}, not a conflict.";
+    readonly 'view.write.not-pending': "That write is already settled.";
+    readonly 'view.write.in-flight': "This view is already being saved; wait for that to finish.";
+    readonly 'view.write.unknown-pending': "The last {action} has not been confirmed yet. Retry it or abandon it before writing again.";
+    readonly 'view.write.conflict': "Someone else saved this view first.";
+    readonly 'view.write.forbidden': "You may not write to this view.";
+    readonly 'view.write.invalid': "The server refused this write: {reason}";
+    readonly 'view.write.not_found': "This view no longer exists.";
+    readonly 'view.write.unavailable': "The server could not be reached.";
+    readonly 'view.write.unavailable.server': "The server could not handle this write: {reason}";
+    readonly 'view.write.unsupported': "This server has no view store.";
+    readonly 'view.write.storage': "This browser could not keep the change: its storage is full or turned off.";
+    readonly 'record.detail.forbidden': "You do not have permission to read this record.";
+    readonly 'view.open.failed.not_found': "This view no longer exists.";
+    readonly 'view.open.failed.forbidden': "You do not have access to this view. Ask an administrator to grant it.";
+    readonly 'view.open.failed.unavailable': "This view could not be loaded: the server could not be reached.";
+    readonly 'view.list.failed.unavailable': "The list of views could not be loaded: the server could not be reached.";
+    readonly 'view.open.failed.unavailable.server': "This view could not be loaded: the server could not handle it ({reason}).";
+    readonly 'view.list.failed.unavailable.server': "The list of views could not be loaded: the server could not handle it ({reason}).";
+    readonly 'view.open.failed.unsupported': "This view could not be loaded: this server has no view store.";
+    readonly 'view.list.failed.unsupported': "The list of views could not be loaded: this server has no view store.";
+    readonly 'label.scope.only-me': "Only me";
+    readonly 'label.scope.everyone': "Everyone";
+    readonly 'label.scope.as-system': "Everyone, as a system view";
+    readonly 'label.scope.group.personal': "My views";
+    readonly 'label.scope.group.shared': "Shared views";
+    readonly 'label.scope.group.system': "System views";
+    readonly 'label.scope.system': "Ships with the definition; cannot be renamed or deleted";
+    readonly 'label.scope.tag.system': "system";
+    readonly 'label.scope.tag.personal': "personal";
+    readonly 'label.scope.tag.shared': "shared";
+    readonly 'label.scope.personal.description': "Only you see it.";
+    readonly 'label.scope.shared.description': "Everyone who uses this data sees it.";
+    readonly 'label.scope.system.description': "Everyone who uses this data sees it among the system views; only those allowed can change it.";
+    readonly 'label.scope.system-stored': "Everyone sees it; only those allowed can change it";
+    readonly 'label.scope.system-editable': "Everyone sees it; you may change it, and the change reaches everyone";
+    readonly 'label.scope.no-permission': "(no permission to create)";
+    readonly 'label.scope.refused': "This page could not narrow this view";
+    readonly 'config.refresh.missing': "This view has no refresh setting.";
+    readonly 'config.refresh.not-an-integer': "The refresh interval must be whole seconds.";
+    readonly 'config.refresh.too-long': "The refresh interval cannot exceed {max} seconds.";
+    readonly 'config.refresh.too-short': "The refresh interval must be at least {min} seconds.";
+    readonly 'config.filter.invalid': "The conditions of this view could not be read.";
+    readonly 'config.filterMode.unknown': "This view has an unknown filter mode.";
+    readonly 'config.filterMode.not-simple': "These conditions need the advanced editor to be shown in full.";
+    readonly 'config.invalid': "This view could not be read.";
+    readonly 'label.filter.simple': "Simple";
+    readonly 'label.filter.advanced': "Advanced";
+    readonly 'label.filter.all-of': "All of";
+    readonly 'label.filter.any-of': "Any of";
+    readonly 'label.filter.none-of': "None of";
+    readonly 'label.filter.panel': "Filter";
+    readonly 'label.filter.mode': "Filter mode";
+    readonly 'label.filter.clear': "Clear";
+    readonly 'label.filter.apply': "Apply";
+    readonly 'label.filter.discard': "Discard edits";
+    readonly 'label.filter.range.discard': "Discard range edits";
+    readonly 'label.filter.range.clear': "Clear range";
+    readonly 'label.filter.all-conditions': "All conditions";
+    readonly 'label.filter.any-condition': "Any condition";
+    readonly 'label.filter.no-condition': "No condition";
+    readonly 'label.filter.pick-fields': "Choose fields";
+    readonly 'label.filter.pick-done': "Done";
+    readonly 'label.filter.add-group': "Add a group";
+    readonly 'label.filter.not-set': "Not set";
+    readonly 'label.filter.number-field': "Number field";
+    readonly 'label.filter.pending': "Not applied yet";
+    readonly 'label.filter.blocked': "{count} to fix";
+    readonly 'label.filter.needs-condition': "Add a condition to run the query";
+    readonly 'label.filter.needs-value': "Give a condition a value to run the query";
+    readonly 'label.filter.kind-unregistered': "This field's kind ({kind}) has no editor registered.";
+    readonly 'label.filter.negate-of': "Negate the {field} condition";
+    readonly 'label.filter.negated': "not";
+    readonly 'label.filter.not-of': "not {condition}";
+    readonly 'label.filter.group-operator': "Group operator";
+    readonly 'label.filter.remove-group': "Remove group";
+    readonly 'label.filter.add': "Add";
+    readonly 'label.filter.add-condition': "Add condition";
+    readonly 'label.filter.condition-of': "{field} condition";
+    readonly 'label.field.none': "No field matches";
+    readonly 'label.field.search': "Search fields";
+    readonly 'label.field.deprecated': "Deprecated";
+    readonly 'label.filter.operator-of': "{field} operator";
+    readonly 'label.filter.value-of': "{field} value";
+    readonly 'label.filter.remove-of': "Remove {field}";
+    readonly 'label.filter.unset-of': "Unset {condition}";
+    readonly 'label.relation.is': "is";
+    readonly 'label.relation.is-not': "is not";
+    readonly 'label.relation.has-any': "has any of";
+    readonly 'label.relation.has-none': "has none of";
+    readonly 'label.relation.has-all': "has all of";
+    readonly 'label.relation.has-no-entries': "has no entries";
+    readonly 'label.relation.has-entries': "has entries";
+    readonly 'label.filter.join': ", ";
+    readonly 'label.filter.any-entry': "has any entry";
+    readonly 'label.filter.range-from': "{field} from";
+    readonly 'label.filter.range-to': "{field} to";
+    readonly 'label.filter.range-join': "~";
+    readonly 'label.filter.within': "{field} in the {period}";
+    readonly 'label.filter.during': "{field} {period}";
+    readonly 'label.filter.answer': "{field}: {value}";
+    readonly 'label.filter.period': "{field} in {period}";
+    readonly 'label.filter.period-week': "{field} in the week of {period}";
+    readonly 'label.filter.segment': "{field} in {segment}";
+    readonly 'label.filter.duration': "{field} since {from} {comparison} {amount} {unit}";
+    readonly 'label.filter.duration-from': "Since which time";
+    readonly 'label.filter.duration-comparison': "Comparison";
+    readonly 'label.filter.duration-amount': "Amount";
+    readonly 'label.filter.duration-unit': "Unit";
+    readonly 'label.filter.duration-pick': "Pick a time…";
+    readonly 'label.filter.new-value-of': "New {field}";
+    readonly 'label.filter.add-value-of': "Add {field}";
+    readonly 'label.filter.add-value': "Add {value}";
+    readonly 'label.filter.remove-value': "Remove {value}";
+    readonly 'label.filter.search-candidates': "Type to search";
+    readonly 'label.filter.candidates-loading': "Searching…";
+    readonly 'label.filter.no-candidate': "No match";
+    readonly 'label.filter.more-candidates': "More";
+    readonly 'label.filter.candidates-failed': "The candidates could not be loaded";
+    readonly 'label.filter.candidates-retry': "Try again";
+    readonly 'label.filter.pick-or-type': "Pick or type a value";
+    readonly 'label.search.hint': "Press Enter to search.";
+    readonly 'label.search.by-words': "{field} (by words)…";
+    readonly 'label.search.clear': "Clear the search";
+    readonly 'label.filter.value-count': "{value} ({count} records)";
+    readonly 'label.filter.value-count-one': "{value} (1 record)";
+    readonly 'label.filter.values-loading': "Reading the values…";
+    readonly 'label.filter.values-failed': "The values could not be read: {reason}";
+    readonly 'label.filter.values-top': "Only the most frequent values are listed; type to narrow";
+    readonly 'label.filter.type-to-add': "Type a value and press Enter";
+    readonly 'label.filter.already-listed': "Already in the list";
+    readonly 'label.filter.not-a-number': "Not a number";
+    readonly 'label.deletion.active': "Not deleted";
+    readonly 'label.deletion.deleted': "Deleted only";
+    readonly 'label.deletion.all': "Deleted included";
+    readonly 'label.boolean.true': "Yes";
+    readonly 'label.boolean.false': "No";
+    readonly 'label.filter.too-large': "This filter is too large to edit here.";
+    readonly 'label.applied.title': "Showing";
+    readonly 'label.applied.title-of': "Showing: {view}";
+    readonly 'label.applied.all': "All records";
+    readonly 'label.applied.scoped': "Set by the page";
+    readonly 'label.applied.implied': "By default";
+    readonly 'label.date.absolute': "Specific dates";
+    readonly 'label.date.relative': "Relative";
+    readonly 'label.date.preset': "A period";
+    readonly 'label.date.past': "In the last";
+    readonly 'label.date.future': "In the next";
+    readonly 'label.date.pick': "Pick a date";
+    readonly 'label.date.shape-of': "{field} kind";
+    readonly 'label.date.direction-of': "{field} direction";
+    readonly 'label.date.amount-of': "{field} amount";
+    readonly 'label.date.unit-of': "{field} unit";
+    readonly 'label.date.period-of': "{field} period";
+    readonly 'label.date.time': "Time";
+    readonly 'label.date.time-from': "From time";
+    readonly 'label.date.time-to': "To time";
+    readonly 'label.date.time-whole-day': "Whole day";
+    readonly 'label.date.time-add': "Set a time";
+    readonly 'label.date.time-remove': "Remove time";
+    readonly 'label.date.time-removed': "Time removed: whole days";
+    readonly 'label.date.time-clear': "Clear {time}";
+    readonly 'label.date.time-cleared': "{time} cleared: the whole day";
+    readonly 'label.date.time-hour': "{time} hour";
+    readonly 'label.date.time-minute': "{time} minute";
+    readonly 'label.date.time-hint': "Left empty, a day runs from 00:00:00 through 23:59:59.999.";
+    readonly 'label.date.calendar-previous': "Go to the previous month";
+    readonly 'label.date.calendar-next': "Go to the next month";
+    readonly 'label.date.calendar-nav': "Month navigation";
+    readonly 'label.date.calendar-today': "Today, {date}";
+    readonly 'label.date.calendar-selected': "{date}, selected";
+    readonly 'label.relative.window.past': "last {amount} {unit}";
+    readonly 'label.relative.window.future': "next {amount} {unit}";
+    readonly 'label.relative.instant.past': "{amount} {unit} ago";
+    readonly 'label.relative.instant.future': "{amount} {unit} ahead";
+    readonly 'label.relative.unit.hour': "hours";
+    readonly 'label.relative.unit.hour-one': "hour";
+    readonly 'label.relative.unit.day': "days";
+    readonly 'label.relative.unit.day-one': "day";
+    readonly 'label.relative.unit.week': "weeks";
+    readonly 'label.relative.unit.week-one': "week";
+    readonly 'label.relative.unit.month': "months";
+    readonly 'label.relative.unit.month-one': "month";
+    readonly 'label.relative.unit.quarter': "quarters";
+    readonly 'label.relative.unit.quarter-one': "quarter";
+    readonly 'label.relative.unit.year': "years";
+    readonly 'label.relative.unit.year-one': "year";
+    readonly 'label.relative.preset.today': "today";
+    readonly 'label.relative.preset.yesterday': "yesterday";
+    readonly 'label.relative.preset.dayBeforeYesterday': "the day before yesterday";
+    readonly 'label.relative.preset.tomorrow': "tomorrow";
+    readonly 'label.relative.preset.thisWeek': "this week";
+    readonly 'label.relative.preset.lastWeek': "last week";
+    readonly 'label.relative.preset.nextWeek': "next week";
+    readonly 'label.relative.preset.thisMonth': "this month";
+    readonly 'label.relative.preset.lastMonth': "last month";
+    readonly 'label.relative.preset.nextMonth': "next month";
+    readonly 'label.relative.preset.thisQuarter': "this quarter";
+    readonly 'label.relative.preset.lastQuarter': "last quarter";
+    readonly 'label.relative.preset.nextQuarter': "next quarter";
+    readonly 'label.relative.preset.thisYear': "this year";
+    readonly 'label.relative.preset.lastYear': "last year";
+    readonly 'label.relative.preset.nextYear': "next year";
+    readonly 'label.relative.preset.weekToDate': "this week so far";
+    readonly 'label.relative.preset.lastWeekToDate': "same days last week";
+    readonly 'label.relative.preset.monthToDate': "this month so far";
+    readonly 'label.relative.preset.lastMonthToDate': "same days last month";
+    readonly 'label.relative.preset.quarterToDate': "this quarter so far";
+    readonly 'label.relative.preset.lastQuarterToDate': "same days last quarter";
+    readonly 'label.relative.preset.yearToDate': "this year so far";
+    readonly 'label.relative.preset.lastYearToDate': "same days last year";
+    readonly 'label.operator.MATCH_ALL': "matches every record";
+    readonly 'label.operator.MATCH_NONE': "matches no record";
+    readonly 'label.operator.ID': "is";
+    readonly 'label.operator.IDS': "is any of";
+    readonly 'label.operator.AGGREGATE_ID': "is";
+    readonly 'label.operator.AGGREGATE_IDS': "is any of";
+    readonly 'label.operator.TENANT_ID': "is";
+    readonly 'label.operator.OWNER_ID': "is";
+    readonly 'label.operator.SPACE_ID': "is";
+    readonly 'label.operator.AND': "and";
+    readonly 'label.operator.OR': "or";
+    readonly 'label.operator.NOR': "nor";
+    readonly 'label.operator.EQ': "is";
+    readonly 'label.operator.NE': "is not";
+    readonly 'label.operator.GT': "more than";
+    readonly 'label.operator.GTE': "at least";
+    readonly 'label.operator.LT': "less than";
+    readonly 'label.operator.LTE': "at most";
+    readonly 'label.operator.CONTAINS': "contains";
+    readonly 'label.operator.STARTS_WITH': "starts with";
+    readonly 'label.operator.ENDS_WITH': "ends with";
+    readonly 'label.operator.IN': "is any of";
+    readonly 'label.operator.NOT_IN': "is none of";
+    readonly 'label.operator.BETWEEN': "between";
+    readonly 'label.operator.CONTAINS_ALL': "has all of";
+    readonly 'label.operator.IS_EMPTY': "has no entries";
+    readonly 'label.operator.IS_EMPTY_STRING': "is blank";
+    readonly 'label.operator.IS_NOT_EMPTY_STRING': "is not blank";
+    readonly 'label.operator.IS_NULL': "is empty";
+    readonly 'label.operator.IS_NOT_NULL': "is not empty";
+    readonly 'label.operator.EXISTS': "exists";
+    readonly 'label.operator.NOT_EXISTS': "does not exist";
+    readonly 'label.operator.DELETION': "is";
+    readonly 'label.operator.ELEMENT_MATCH': "has an entry where";
+    readonly 'label.operator.SEARCH': "contains";
+    readonly 'label.operator.TODAY': "today";
+    readonly 'label.operator.BEFORE_TODAY': "before today";
+    readonly 'label.operator.TOMORROW': "tomorrow";
+    readonly 'label.operator.THIS_WEEK': "this week";
+    readonly 'label.operator.NEXT_WEEK': "next week";
+    readonly 'label.operator.LAST_WEEK': "last week";
+    readonly 'label.operator.THIS_MONTH': "this month";
+    readonly 'label.operator.LAST_MONTH': "last month";
+    readonly 'label.operator.YESTERDAY': "yesterday";
+    readonly 'label.operator.NEXT_MONTH': "next month";
+    readonly 'label.operator.LAST_YEAR': "last year";
+    readonly 'label.operator.THIS_YEAR': "this year";
+    readonly 'label.operator.NEXT_YEAR': "next year";
+    readonly 'label.operator.RECENT_DAYS': "recent days";
+    readonly 'label.operator.EARLIER_DAYS': "earlier days";
+    readonly 'label.operator.BEFORE_NOW': "before now";
+    readonly 'label.operator.AFTER_NOW': "after now";
+    readonly 'label.operator.EXPRESSION': "time since";
+    readonly 'filter.value.expected-duration': "A time since needs an earlier time, a comparison, an amount and a unit.";
+    readonly 'filter.value.duration-same-time': "A time cannot be measured since itself.";
+    readonly 'filter.value.duration-from-unknown': "The earlier time {field} is not a field here.";
+    readonly 'filter.value.duration-from-not-time': "{field} holds no time.";
+    readonly 'filter.element.duration': "A time since another moment cannot be asked of one entry.";
+    readonly 'filter.field.reference-without-source': "{field} is a reference field with no candidate source declared.";
+    readonly 'filter.field.duplicate-in-group': "{field} is already a condition in this group. Nest a group to ask it something else.";
+    readonly 'filter.field.unknown': "The field {field} no longer exists.";
+    readonly 'filter.group.unknown-operator': "A condition group must be AND or OR.";
+    readonly 'filter.kind.unregistered': "No editor is registered for the {kind} type.";
+    readonly 'filter.kind.unknown-editor': "The {kind} type asks for a {input} editor, which this engine does not have.";
+    readonly 'filter.kind.failed': "The condition on \"{label}\" couldn't be checked; ask whoever maintains this view.";
+    readonly 'filter.node.invalid': "This condition could not be read.";
+    readonly 'filter.operator.unsupported': "{field} does not support {operator}.";
+    readonly 'filter.presence.empty-is-missing': "On this source, an empty value of {field} counts as no value.";
+    readonly 'filter.tree.too-deep': "The conditions nest deeper than {max} levels.";
+    readonly 'filter.tree.too-many-nodes': "The conditions exceed {max} entries.";
+    readonly 'filter.value.expected-boolean': "Choose yes or no.";
+    readonly 'filter.value.expected-deletion-state': "Choose which records to show: not deleted, deleted only, or both.";
+    readonly 'filter.value.expected-date': "Enter a date.";
+    readonly 'filter.value.expected-id': "Enter an id, or pick a candidate.";
+    readonly 'filter.value.expected-id-list': "Enter one or more ids.";
+    readonly 'filter.value.expects-one': "This condition takes a single value.";
+    readonly 'filter.value.expected-text': "Type what to search for.";
+    readonly 'filter.element.root-filter': "{field} asks about the whole record, so it cannot be asked of one entry.";
+    readonly 'filter.value.expected-predicate': "Describe what an entry must match.";
+    readonly 'filter.field.holds-no-elements': "{field} holds no entries to match against.";
+    readonly 'filter.value.expected-entry-list': "Choose or enter one or more entries.";
+    readonly 'filter.value.expected-number': "Enter a number.";
+    readonly 'filter.value.expected-number-list': "Enter one or more numbers.";
+    readonly 'filter.value.expected-number-range': "Enter a range of two numbers.";
+    readonly 'filter.value.expected-option-list': "Choose one or more options.";
+    readonly 'filter.value.expected-reference-list': "Choose one or more records.";
+    readonly 'filter.value.expected-string': "Enter a value.";
+    readonly 'filter.value.expected-string-list': "Enter one or more values.";
+    readonly 'filter.value.inverted-range': "The range starts after it ends.";
+    readonly 'filter.value.relative-too-large': "A relative window can reach at most {max} units.";
+    readonly 'filter.value.required': "This condition needs a value.";
+    readonly 'filter.value.unknown-option': "{values} is no longer an option.";
+    readonly 'filter.value.unknown-time-zone': "{timeZone} is not a time zone this browser knows.";
+    readonly 'filter.value.unparsable-date': "That date cannot be read.";
+    readonly 'label.export.title': "Export";
+    readonly 'label.export.currency-column': "{field} (currency)";
+    readonly 'label.export.data': "Export data…";
+    readonly 'label.export.image-png': "Export image (PNG)";
+    readonly 'label.export.image-svg': "Export image (SVG)";
+    readonly 'label.export.image-failed': "The image could not be made. Try again, or export it as SVG.";
+    readonly 'label.export.image-name': "Chart";
+    readonly 'label.export.description': "The result leaves as a CSV file.";
+    readonly 'label.export.scope': "What to export";
+    readonly 'label.export.selected': "Selected ({count})";
+    readonly 'label.export.all': "All ({count}, under the current conditions)";
+    readonly 'label.export.all-unknown': "All (under the current conditions)";
+    readonly 'label.export.rows': "{count} records";
+    readonly 'label.export.rows-one': "1 record";
+    readonly 'label.export.rows-unknown': "Whatever the current conditions match";
+    readonly 'label.export.conditions': "Conditions: {conditions}";
+    readonly 'label.export.columns': "{count} columns: {names}";
+    readonly 'label.export.columns-one': "1 column: {names}";
+    readonly 'label.export.file': "File: {name}";
+    readonly 'label.export.over-limit': "That is more than the {max} one export carries; the file will hold the first {max}.";
+    readonly 'label.export.confirm': "Export";
+    readonly 'label.export.running': "Exporting";
+    readonly 'label.export.progress': "{fetched} of {total} fetched";
+    readonly 'label.export.progress-unknown': "{fetched} fetched";
+    readonly 'label.export.done': "{count} records exported";
+    readonly 'label.export.done-one': "1 record exported";
+    readonly 'label.export.done-capped': "The file holds the first {max} of the {total} records that match.";
+    readonly 'label.export.done-capped-unknown': "The file holds the first {max} records; more match than that.";
+    readonly 'label.export.retry': "Try again";
+    readonly 'label.export.groups': "{count} groups";
+    readonly 'label.export.groups-one': "1 group";
+    readonly 'label.export.groups-first': "The first {count} groups (there are more; the file leaves them out)";
+    readonly 'label.export.groups-first-one': "The first group (there are more; the file leaves them out)";
+    readonly 'label.export.whole': "1 row: every record in the range";
+    readonly 'label.export.and-totals': "{rows}, then a totals row";
+    readonly 'label.export.done-analysis': "Exported: {rows}";
+    readonly 'export.failed': "The export failed. {reason}";
+    readonly 'label.refresh.auto': "Auto refresh";
+    readonly 'label.refresh.off': "Off";
+    readonly 'label.refresh.seconds': "{count}s";
+    readonly 'label.refresh.minutes': "{count} min";
+    readonly 'label.refresh.hours': "{count} h";
+    readonly 'label.refresh.on': "This view refreshes itself every {interval}.";
+    readonly 'label.refresh.panels': "Every panel on this dashboard refreshes together, on this interval; an interval saved with the view a panel shows does not apply here.";
+    readonly 'label.refresh.read-at': "Updated {time}";
+    readonly 'label.layout.table': "Table";
+    readonly 'label.layout.chart': "Chart";
+    readonly 'label.layout.cards': "Cards";
+    readonly 'label.card.title': "Card settings";
+    readonly 'label.card.hint': "Cards take their title, body and image from here.";
+    readonly 'label.card.title-field': "Title";
+    readonly 'label.card.image-field': "Image";
+    readonly 'label.card.no-image': "No image";
+    readonly 'label.card.fields': "Body";
+    readonly 'label.card.per-row': "Cards per row";
+    readonly 'label.card.per-row-option': "{count} per row";
+    readonly 'label.toolbar.title': "Result toolbar";
+    readonly 'label.toolbar.layout': "Layout";
+    readonly 'label.toolbar.columns': "Columns";
+    readonly 'label.toolbar.card': "Card settings";
+    readonly 'label.toolbar.refresh': "Refresh";
+    readonly 'label.toolbar.arrange': "Table settings";
+    readonly 'label.toolbar.freshness': "Freshness";
+    readonly 'label.toolbar.selected': "{count} selected";
+    readonly 'label.toolbar.clear-selection': "Clear selection";
+    readonly 'label.toolbar.actions': "Actions";
+    readonly 'label.toolbar.page': "Page {index}";
+    readonly 'label.toolbar.page-of': "Page {index} of {pages}";
+    readonly 'label.toolbar.previous': "Previous page";
+    readonly 'label.toolbar.next': "Next page";
+    readonly 'label.pagination.nav': "Pagination";
+    readonly 'label.pagination.total': "{count} records in all";
+    readonly 'label.pagination.total-one': "1 record in all";
+    readonly 'label.pagination.on-page': "{count} on this page";
+    readonly 'label.pagination.page-size': "Per page";
+    readonly 'label.pagination.page-size-option': "{size} per page";
+    readonly 'label.pagination.go-to': "Go to page";
+    readonly 'label.pagination.window': "Only the first {count} records can be paged through; narrow the conditions to see the rest";
+    readonly 'label.record.empty': "Nothing to show";
+    readonly 'label.record.empty-hint': "No record matches the current conditions.";
+    readonly 'label.record.empty-clear': "Clear the conditions";
+    readonly 'label.record.empty-add': "Add a condition";
+    readonly 'label.record.empty-restore': "Back to the saved conditions";
+    readonly 'label.record.empty-edit': "Change the conditions";
+    readonly 'label.record.empty-view': "This view has no records right now.";
+    readonly 'label.record.empty-none': "There are no records yet.";
+    readonly 'label.record.filter-required': "Add a condition first";
+    readonly 'label.record.filter-required-hint': "This data source does not list every record at once. Add a condition to narrow what it lists.";
+    readonly 'label.record.select-all': "Select all rows";
+    readonly 'label.record.select': "Select {key}";
+    readonly 'label.record.select.hint': "Hold Shift to select or clear every record from the last one you picked to this one.";
+    readonly 'label.record.detail': "Record detail";
+    readonly 'label.record.detail.hint': "Enter or Space opens the record; the arrow keys move between records.";
+    readonly 'label.record.detail.loading': "Reading the whole record…";
+    readonly 'label.record.detail.missing': "This record is no longer there — it may have been deleted, or it is outside what you can see.";
+    readonly 'label.record.detail.partial': "Showing the fields the list had.";
+    readonly 'label.record.detail.other': "Other";
+    readonly 'label.record.detail.element': "Item {index}";
+    readonly 'label.record.detail.retry': "Try again";
+    readonly 'label.record.detail.back': "Back to {key}";
+    readonly 'label.copy-of': "Copy {value}";
+    readonly 'label.copied': "Copied";
+    readonly 'label.copy-failed': "Could not copy — select the value and copy it";
+    readonly 'label.summary.of': "{fn} of {field}";
+    readonly 'label.value.yes': "Yes";
+    readonly 'label.value.no': "No";
+    readonly 'label.value.items': "{count} items";
+    readonly 'label.value.items-one': "1 item";
+    readonly 'label.value.fields': "{count} fields";
+    readonly 'label.value.fields-one': "1 field";
+    readonly 'label.value.mixed-currencies': "Mixed currencies";
+    readonly 'label.value.untitled': "Untitled";
+    readonly 'label.value.more': "+{count}";
+    readonly 'label.sort.ascending': "Sort by {field}, ascending";
+    readonly 'label.sort.descending': "Sort by {field}, descending";
+    readonly 'label.sort.none': "Stop sorting by {field}";
+    readonly 'label.sort.restore': "Back to the order before sorting by {field}";
+    readonly 'label.sort.waiting.asc': "ascending waits for Apply";
+    readonly 'label.sort.waiting.desc': "descending waits for Apply";
+    readonly 'label.sort.waiting.none': "unsorted waits for Apply";
+    readonly 'label.sort.at': "sort {position} of {count}";
+    readonly 'label.sort.additive': "Hold Shift to add to the sort";
+    readonly 'label.summary.total': "Total";
+    readonly 'label.summary.scope.page': "This page";
+    readonly 'label.summary.scope.total': "All rows";
+    readonly 'label.summary.fn.none': "No summary";
+    readonly 'label.summary.fn.SUM': "Sum";
+    readonly 'label.summary.fn.AVG': "Average";
+    readonly 'label.summary.fn.MIN': "Min";
+    readonly 'label.summary.fn.MAX': "Max";
+    readonly 'label.summary.fn.COUNT': "Count";
+    readonly 'label.summary.fn.date.MIN': "Earliest";
+    readonly 'label.summary.fn.date.MAX': "Latest";
+    readonly 'label.summary.fn.STDDEV': "Standard deviation";
+    readonly 'label.summary.fn.VARIANCE': "Variance";
+    readonly 'label.summary.fn.DISTINCT_COUNT': "Distinct count";
+    readonly 'label.summary.fn.PERCENTILE': "Percentile";
+    readonly 'label.summary.fn.FIRST': "Opening value";
+    readonly 'label.summary.fn.LAST': "Closing value";
+    readonly 'label.summary.fn.ANY': "Any value";
+    readonly 'label.summary.fn.ANY.item': "Any value (not stable)";
+    readonly 'label.summary.unavailable': "—";
+    readonly 'label.summary.offscreen.more': "({count} in all)";
+    readonly 'label.summary.offscreen.go': ", out of view. Scroll to {field}";
+    readonly 'label.summary.offscreen.go-in-scope': ", {scope}, out of view. Scroll to {field}";
+    readonly 'label.columns.title': "Column settings";
+    readonly 'label.columns.hint': "The table draws its columns in the order listed here.";
+    readonly 'label.columns.resize-keys': "On a column header, Alt+← and Alt+→ change its width (Shift for bigger steps); Alt+Enter fits it to its content.";
+    readonly 'label.columns.width': "Width of {field}, in pixels";
+    readonly 'label.columns.width-auto': "Auto";
+    readonly 'label.columns.width-invalid': "Type a whole number of pixels, or leave it empty to fit the content.";
+    readonly 'label.columns.filtered': "Clear the search to reorder columns.";
+    readonly 'label.columns.drag': "Reorder {field}";
+    readonly 'label.columns.moved': "{field} moved to position {index} of {total}";
+    readonly 'label.columns.picked': "{field} picked up";
+    readonly 'label.columns.cancelled': "Move cancelled; {field} stayed where it was";
+    readonly 'label.columns.show': "Show {field}";
+    readonly 'label.columns.primary-required': "The row key is always shown: it says which record a row is.";
+    readonly 'label.columns.hidden': "Show this column before pinning or summarising it.";
+    readonly 'label.columns.unknown': "This column is not in the data any more; switch it off to take it out.";
+    readonly 'label.columns.summary-unknown': "Only a summary refers to this field, which is not in the data any more; switch it off to take the summary out.";
+    readonly 'label.columns.keep-summary': "Keep the summary of {field}";
+    readonly 'label.columns.summary': "Summary under {field}";
+    readonly 'label.columns.resize': "Resize {field}";
+    readonly 'label.columns.resized': "{field} is {width} px wide";
+    readonly 'label.columns.resized-auto': "{field} fits its content";
+    readonly 'label.columns.pin': "Pin {field}";
+    readonly 'label.columns.pin.none': "Not pinned";
+    readonly 'label.columns.pin.left': "Pinned left";
+    readonly 'label.columns.pin-released': "let go while the area is too narrow";
+    readonly 'label.columns.pinned.none': "{field} is no longer pinned";
+    readonly 'label.columns.pinned.left': "{field} is now pinned left";
+    readonly 'label.sort.title': "Sort";
+    readonly 'label.sort.button': "Sort: {field} {direction}";
+    readonly 'label.sort.hint': "Rows are ordered by the first field, then by the next.";
+    readonly 'label.sort.unsorted': "These rows are in no particular order.";
+    readonly 'label.sort.asc': "Ascending";
+    readonly 'label.sort.desc': "Descending";
+    readonly 'label.sort.more': "+{count}";
+    readonly 'label.sort.direction': "Direction of {field}";
+    readonly 'label.sort.add': "Sort by a field";
+    readonly 'label.sort.full': "These rows can be ordered by at most {max} fields.";
+    readonly 'label.sort.groups.none': "Not sorted";
+    readonly 'label.sort.groups.hint': "Groups are ordered by the first, then by the next where they tie.";
+    readonly 'label.sort.groups.unsorted': "These groups are in no particular order.";
+    readonly 'label.sort.groups.add': "Sort by a dimension or metric";
+    readonly 'label.sort.groups.full': "Groups can be ordered by at most {max} dimensions and metrics.";
+    readonly 'label.sort.drag': "Reorder {field}";
+    readonly 'label.sort.moved': "{field} moved to position {index} of {total}";
+    readonly 'label.sort.picked': "{field} picked up";
+    readonly 'label.sort.cancelled': "Move cancelled; {field} stayed where it was";
+    readonly 'record.capability.missing': "{definition} does not offer a record view any more.";
+    readonly 'record.card.invalid': "The card settings could not be read.";
+    readonly 'record.column.duplicate': "The column {field} is listed twice.";
+    readonly 'record.column.hidden-invalid': "The column {field} is switched off as {hidden}, which is not how a column is switched off.";
+    readonly 'record.column.pin-invalid': "The column {field} is pinned as {pinned}, which is not how a column is pinned.";
+    readonly 'record.column.width-invalid': "The column {field} is {width} wide, which is not a number of pixels.";
+    readonly 'record.field.not-a-column': "{field} is a search or metadata handle, not something a row holds.";
+    readonly 'record.field.unknown': "The column {field} no longer exists.";
+    readonly 'record.layout.unsupported': "The {layout} layout is not available here.";
+    readonly 'record.filter.required': "This data source lists records only under a condition: add one first.";
+    readonly 'record.pageSize.not-positive': "The page size must be a positive number.";
+    readonly 'record.pageSize.too-large': "The page size cannot exceed {max}.";
+    readonly 'record.sort.direction-invalid': "The sort on {field} reads neither ascending nor descending.";
+    readonly 'record.sort.duplicate': "The sort already orders by {field}.";
+    readonly 'record.sort.parallel-arrays': "The source cannot sort by {fields} together: keep one of them.";
+    readonly 'record.sort.invalid': "The sort settings could not be read.";
+    readonly 'record.sort.not-sortable': "{field} cannot be sorted on.";
+    readonly 'record.sort.too-many': "A cursor view sorts on at most {max} fields.";
+    readonly 'record.summaries.invalid': "The summary settings could not be read.";
+    readonly 'record.summary.duplicate': "The {fn} summary of {field} is listed twice.";
+    readonly 'record.summary.unsupported': "{field} does not offer the {fn} summary.";
+    readonly 'record.table.invalid': "The table settings could not be read.";
+    readonly 'label.header.new-view': "Not saved yet";
+    readonly 'label.header.unsaved': "Edited";
+    readonly 'label.header.unsaved-look': "Only the look changed";
+    readonly 'label.header.more': "More view actions";
+    readonly 'label.editor.pending': "{count} not applied";
+    readonly 'label.save.save': "Save";
+    readonly 'label.save.save-as': "Save as";
+    readonly 'label.save.revert': "Revert";
+    readonly 'label.save.title': "Title";
+    readonly 'label.save.audience': "Who can see it";
+    readonly 'label.save.group': "View actions";
+    readonly 'label.save.saving': "Saving…";
+    readonly 'label.save.saved': "Saved";
+    readonly 'label.save.saved-announce': "View saved";
+    readonly 'label.save.shared-heading': "Update it for everyone?";
+    readonly 'label.save.shared-description': "This updates “{title}” for everyone who can see it.";
+    readonly 'label.save.shared-confirm': "Update for everyone";
+    readonly 'label.delete.confirm': "Delete “{title}”?";
+    readonly 'label.delete.consequence': "Only the view is removed; its records stay.";
+    readonly 'label.delete.shared-consequence': "Everyone who uses it loses it.";
+    readonly 'label.delete.system-consequence': "Once it is deleted, no one sees this system view any more.";
+    readonly 'label.delete.dirty-consequence': "Unsaved changes go with it.";
+    readonly 'label.delete.keep': "Keep it";
+    readonly 'label.dialog.cancel': "Cancel";
+    readonly 'label.dialog.close': "Close";
+    readonly 'label.save-as.heading': "Save as a new view";
+    readonly 'label.save-as.description': "The view you are looking at stays as it is.";
+    readonly 'label.save-as.copy-title': "{title} copy";
+    readonly 'label.save-as.submit': "Create view";
+    readonly 'label.save.first-heading': "Save this view";
+    readonly 'label.save.first-description': "Name it and say who it is for.";
+    readonly 'label.conflict.choice': "Take their version and lose your edits, or write yours over theirs.";
+    readonly 'label.conflict.theirs': "Take theirs";
+    readonly 'label.conflict.mine': "Keep mine";
+    readonly 'label.conflict.copy': "Save my copy";
+    readonly 'label.conflict.confirm-theirs': "Take their version?";
+    readonly 'label.conflict.confirm-mine': "Write yours over theirs?";
+    readonly 'label.conflict.local': "Mine";
+    readonly 'label.conflict.remote': "Theirs";
+    readonly 'label.conflict.summary.record': "{pageSize} per page · {layout} · {columns} columns · {sorts} sorts";
+    readonly 'label.conflict.summary.analysis': "{groups} dimensions · {metrics} metrics · top {limit} groups";
+    readonly 'label.conflict.summary.dashboard': "{count} panels";
+    readonly 'label.conflict.summary.dashboard-one': "1 panel";
+    readonly 'label.conflict.summary.malformed': "Cannot be read";
+    readonly 'label.unknown.leave': "Abandon";
+    readonly 'label.unknown.retry': "Try again";
+    readonly 'label.rejected.dismiss': "Dismiss";
+    readonly 'label.leave.heading': "Leave this view?";
+    readonly 'label.leave.consequence': "Unsaved changes will be lost.";
+    readonly 'label.leave.stay': "Stay";
+    readonly 'label.leave.leave': "Leave";
+    readonly 'label.revert.heading': "Go back to the saved version?";
+    readonly 'label.revert.consequence': "Unsaved changes will be lost.";
+    readonly 'label.revert.keep': "Keep editing";
+};
+//# sourceMappingURL=en.d.ts.map