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

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

@@ -0,0 +1,172 @@
+/** The record view: its layouts, toolbar, paging, rows and summaries. */
+export declare const recordMessages: {
+    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.";
+};
+//# sourceMappingURL=record.d.ts.map

package/dist/ui/messages/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/record.ts"],"names":[],"mappings":"AAaA,yEAAyE;AACzE,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4VgB,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * Auto refresh: the interval menu behind the refresh button's `▾`, and the
+ * cadence the button wears while one is in force.
+ *
+ * The three units are three keys rather than one sentence with a unit in it:
+ * a catalogue that named only "minute" would leave every other language
+ * writing "5 minute" or reordering the number by hand.
+ */
+export declare const refreshMessages: {
+    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}";
+};
+//# sourceMappingURL=refresh.d.ts.map

package/dist/ui/messages/refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/refresh.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;CAkBe,CAAC"}

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

@@ -0,0 +1,11 @@
+/**
+ * What a render boundary says where a part of the view failed to draw. The
+ * error's own words are shown beside these, unlocalised — they are the
+ * host's, and the host is who has to read them.
+ */
+export declare const renderMessages: {
+    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";
+};
+//# sourceMappingURL=render.d.ts.map

package/dist/ui/messages/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/render.ts"],"names":[],"mappings":"AAaA;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;CAOgB,CAAC"}

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

@@ -0,0 +1,19 @@
+/**
+ * What every list that can be put in another order says the same way: how
+ * its handle is worked, and the four places its menu offers (the one-click
+ * way to move a row, for a pointer that cannot drag — WCAG 2.5.7).
+ *
+ * One family for every list, because the handle is one component
+ * (`DragHandle`) and a reader who learned it in the column settings should
+ * hear the same sentence on a funnel's stages. What differs per list — the
+ * handle's name, what a pick-up and a landing say — stays in that list's
+ * own family, since those name the thing being carried.
+ */
+export declare const reorderMessages: {
+    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";
+};
+//# sourceMappingURL=reorder.d.ts.map

package/dist/ui/messages/reorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reorder.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/reorder.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe;;;;;;CAOlB,CAAC"}

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

@@ -0,0 +1,59 @@
+/**
+ * The save commands, their dialogs, and what a write settled as.
+ *
+ * Conflict and delete carry the most weight of anything this package says, so
+ * they are the last copy that should be stranded in JSX where no application
+ * can reword or translate it.
+ */
+export declare const saveMessages: {
+    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=save.d.ts.map

package/dist/ui/messages/save.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/save.ts"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFkB,CAAC"}

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

@@ -0,0 +1,28 @@
+/**
+ * Who a view is for.
+ *
+ * The audience picker asks it of the person saving; the list answers it with
+ * the group a view sits in, so the two are worded differently and keyed apart.
+ * Nothing names the shared or personal audience on the row itself — the group
+ * above it already did.
+ */
+export declare const scopeMessages: {
+    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";
+};
+//# sourceMappingURL=scope.d.ts.map

package/dist/ui/messages/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/scope.ts"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;CA8BiB,CAAC"}

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

@@ -0,0 +1,28 @@
+/**
+ * What the view says about itself: what failed, what is still on screen, and
+ * whether something is running right now.
+ */
+export declare const statusMessages: {
+    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";
+};
+//# sourceMappingURL=status.d.ts.map

package/dist/ui/messages/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/status.ts"],"names":[],"mappings":"AAaA;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;CAmDgB,CAAC"}

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

@@ -0,0 +1,160 @@
+/** A view itself: which kind it is, the list it sits in, and the commands. */
+export declare const viewMessages: {
+    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.";
+};
+//# sourceMappingURL=view.d.ts.map

package/dist/ui/messages/view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/view.ts"],"names":[],"mappings":"AAaA,8EAA8E;AAC9E,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4TkB,CAAC"}

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

@@ -0,0 +1,21 @@
+/**
+ * The frame around a view rather than the view itself: the sidebar's two
+ * states, the switcher that stands in for the list once it is away, and the
+ * two states of the view filling the screen.
+ *
+ * They are the accessible names of icon-only controls, which is why they
+ * describe what happens rather than what is drawn: "Hide the view list" is
+ * what the button does, "Collapse" is only where it points.
+ */
+export declare const workbenchMessages: {
+    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";
+};
+//# sourceMappingURL=workbench.d.ts.map

package/dist/ui/messages/workbench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/workbench.ts"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;CA8Ba,CAAC"}

package/dist/ui/messages/zh-CN.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 简体中文文案，与 `en` 逐键对应。
+ *
+ * `satisfies Record<keyof typeof en, string>`（即 `MessageKey`）让少一个键或多一个键都成为编译错误，
+ * 类型取自 `en` 本身，因为文案目录在 `kit` 之下、不向上引用。
+ * `test/messages.test.tsx` 另外核对每句里的 `{param}` 占位符。
+ *
+ * 宿主要改其中几句，把它铺开再覆盖即可：
+ * `messages={{ ...zhCN, 'label.filter.apply': '确定' }}`。
+ */
+export declare const zhCN: Readonly<Record<string, string>>;
+//# sourceMappingURL=zh-CN.d.ts.map

package/dist/ui/messages/zh-CN.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zh-CN.d.ts","sourceRoot":"","sources":["../../../src/ui/messages/zh-CN.ts"],"names":[],"mappings":"AAeA;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA44EP,CAAC"}