@overvis/hmi-workspace-ui 0.0.0-stage → 0.1.0

package/dist/src/i18n/catalogs/en/automation-editor.d.ts

@@ -0,0 +1,220 @@
+declare const _default: {
+    readonly setup_menu_automations: "Automations";
+    readonly setup_automations_title: "Automations";
+    readonly setup_automations_description: "Automations read parameters, decide, write values and send notifications on the server.";
+    readonly setup_automations_empty: "No automations yet.";
+    readonly setup_alarm_rules_description: "Alarm rules raise an alarm while a condition holds and notify the people you choose.";
+    readonly setup_alarm_rules_empty: "No alarm rules yet.";
+    readonly automation_tab_automations: "Automations";
+    readonly automation_tab_alarm_rules: "Alarm rules";
+    readonly automation_tab_editor: "Editor";
+    readonly automation_tab_history: "Run history";
+    readonly automation_create_action: "New automation";
+    readonly automation_create_title: "New automation";
+    readonly automation_create_submit: "Create automation";
+    readonly automation_create_toast: "Automation created.";
+    readonly automation_save_toast: "Automation saved.";
+    readonly automation_new_name: "New automation";
+    readonly automation_delete_action: "Delete automation";
+    readonly automation_delete_confirm_title: "Delete this automation?";
+    readonly automation_delete_confirm_description: "It stops running, and its stored state and run history are no longer shown.";
+    readonly automation_delete_confirm_submit: "Delete";
+    readonly automation_delete_toast: "Automation deleted.";
+    readonly automation_enabled_label: "Enabled";
+    readonly automation_enabled: "Enabled";
+    readonly automation_disabled: "Disabled";
+    readonly automation_enable_toast: "Enabled.";
+    readonly automation_disable_toast: "Disabled.";
+    readonly automation_error_count: "Errors: {count}";
+    readonly automation_warning_count: "Warnings: {count}";
+    readonly automation_owned_by: "Belongs to the dashboard {owner}";
+    readonly automation_last_run_none: "Has not run yet";
+    readonly automation_last_run_ok: "Last run {at}";
+    readonly automation_last_run_failed: "Last run {at} failed: {error}";
+    readonly automation_field_dashboard: "Dashboard";
+    readonly automation_field_dashboard_description: "A dashboard that owns it edits it, and deleting that dashboard deletes it.";
+    readonly automation_editor_document: "Automation document";
+    readonly automation_editor_json_syntax: "This is not valid JSON.";
+    readonly automation_editor_no_problems: "No problems";
+    readonly automation_editor_problem_counts: "Errors: {errors}, warnings: {warnings}";
+    readonly automation_editor_unsaved: "Unsaved changes";
+    readonly automation_editor_keyboard_hint: "Ctrl+Space suggests; F12 or Ctrl+click goes to a definition. Tab takes a suggestion or indents; press Esc, then Tab, to leave the editor.";
+    readonly automation_editor_problems: "Problems";
+    readonly automation_editor_save_has_errors: "Fix the errors before saving.";
+    readonly automation_editor_step_budget: "Steps per run";
+    readonly automation_editor_step_budget_description: "The most steps one run of each procedure can take. The workspace allows {limit}.";
+    readonly automation_editor_limits: "Workspace limits";
+    readonly automation_limit_steps: "Steps per run";
+    readonly automation_limit_interval: "Shortest interval";
+    readonly automation_limit_writes: "Writes per minute";
+    readonly automation_seconds: "{seconds} s";
+    readonly automation_dry_run_title: "Dry run";
+    readonly automation_dry_run_description: "Runs a procedure of the document as it is now, with current values and the stored state. Nothing is written, notified or raised.";
+    readonly automation_dry_run_procedure: "Procedure";
+    readonly automation_dry_run_command: "As a Telegram command";
+    readonly automation_dry_run_submit: "Dry run";
+    readonly automation_dry_run_needs_valid: "Fix the errors to run the document.";
+    readonly automation_dry_run_summary: "{procedure} at {at}: {steps} of {limit} steps";
+    readonly automation_dry_run_applied_nothing: "This was a dry run: nothing was written, notified, raised or stored.";
+    readonly automation_dry_run_effects: "Would do";
+    readonly automation_dry_run_no_effects: "Nothing: no writes, notifications or alarms.";
+    readonly automation_dry_run_failed_applies_nothing: "The run failed, so a real run would apply none of this.";
+    readonly automation_dry_run_state_before: "State before";
+    readonly automation_dry_run_state_after: "State after";
+    readonly automation_effect_alarm: "{key}: {title}";
+    readonly automation_history_description: "Runs are kept for 90 days, the steps of each run for 7 days.";
+    readonly automation_history_failed_only: "Failed only";
+    readonly automation_history_refresh: "Refresh";
+    readonly automation_history_older: "Show older runs";
+    readonly automation_history_empty_title: "No runs";
+    readonly automation_history_empty_description: "Runs appear here once the automation is enabled and a trigger starts it.";
+    readonly automation_run_ok: "Succeeded";
+    readonly automation_run_failed: "Failed";
+    readonly automation_run_duration: "Took {duration}";
+    readonly automation_run_step_count: "Steps: {steps}";
+    readonly automation_run_write_count: "Writes: {writes}";
+    readonly automation_run_limited_count: "Writes over the limit: {writes}";
+    readonly automation_run_notification_count: "Notifications: {notifications}";
+    readonly automation_run_inputs: "Input values";
+    readonly automation_run_no_inputs: "No input variables.";
+    readonly automation_run_no_state: "No state variables.";
+    readonly automation_run_steps: "Steps";
+    readonly automation_run_no_steps: "No steps ran.";
+    readonly automation_run_trace_expired: "The steps of this run are no longer kept.";
+    readonly automation_run_trace_truncated: "The run took {steps} steps; only the first 1000 are kept.";
+    readonly automation_run_earlier_version: "This run used an earlier version of the automation, so its steps are shown by position and do not open in the editor.";
+    readonly automation_value_unknown: "unknown";
+    readonly automation_location_branch: "branch {n}";
+    readonly automation_location_else: "else";
+    readonly automation_trigger_input_change: "Inputs changed: {inputs}";
+    readonly automation_trigger_period: "Period";
+    readonly automation_trigger_time_of_day: "Time of day";
+    readonly automation_trigger_sun: "Sunrise or sunset";
+    readonly automation_trigger_alarm: "Alarm changed";
+    readonly automation_trigger_automation: "Another automation ran";
+    readonly automation_trigger_telegram: "Telegram command {command}";
+    readonly automation_trigger_init: "Enabled";
+    readonly automation_trigger_hold: "Condition held long enough";
+    readonly automation_trigger_load: "Loading";
+    readonly automation_run_error_fail: "Stopped by a fail step: {message}";
+    readonly automation_run_error_expression: "A formula failed.";
+    readonly automation_run_error_expression_detail: "A formula failed: {problem}";
+    readonly automation_run_error_invalid_formula: "A formula no longer fits the variables.";
+    readonly automation_run_error_invalid_formula_detail: "A formula no longer fits the variables: {problem}";
+    readonly automation_run_error_step_limit: "The run reached the limit of {limit} steps.";
+    readonly automation_run_error_value_too_long: "A text was longer than {limit} characters.";
+    readonly automation_run_error_unknown_procedure: "There is no procedure {name}.";
+    readonly automation_run_error_invalid: "The automation has errors, so it does not run.";
+    readonly automation_run_error_alarms_unavailable: "This automation did not run: automations could not use alarms then.";
+    readonly automation_run_error_location_missing: "Sunrise and sunset need the workspace location, so the trigger did not fire.";
+    readonly automation_run_error_init_not_stored: "The run on enabling could not be stored and will be repeated.";
+    readonly automation_run_error_not_stored: "The run could not be stored; nothing it did was applied.";
+    readonly automation_step_if: "if";
+    readonly automation_step_call: "call";
+    readonly automation_step_repeat: "repeat";
+    readonly automation_step_set: "set";
+    readonly automation_step_write_parameter: "write";
+    readonly automation_step_raise_alarm: "raise alarm";
+    readonly automation_step_clear_alarm: "clear alarm";
+    readonly automation_step_notify: "notify";
+    readonly automation_step_cancel_notify: "cancel notification";
+    readonly automation_step_write_log: "log";
+    readonly automation_step_fail: "fail";
+    readonly automation_step_reply: "reply";
+    readonly automation_step_write_limited: "write over the limit";
+    readonly automation_step_write_dropped: "writes not sent";
+    readonly automation_step_write_failed: "write failed";
+    readonly automation_step_if_branch: "branch {branch}";
+    readonly automation_step_if_else: "else";
+    readonly automation_step_if_none: "no branch";
+    readonly automation_step_if_unknown: "no branch: a condition was unknown";
+    readonly automation_step_if_once: "no branch: already ran once";
+    readonly automation_step_repeat_times: "{times} times";
+    readonly automation_step_write_skipped: "{parameter}: not written, the value is unknown";
+    readonly automation_step_reply_skipped: "not sent: no Telegram command started the run";
+    readonly automation_step_write_dropped_late: "stored too late to send";
+    readonly automation_step_write_dropped_lease: "another server took over the workspace";
+    readonly automation_step_write_failed_detail: "{parameter}: {error}";
+    readonly automation_severity_info: "Info";
+    readonly automation_severity_warning: "Warning";
+    readonly automation_severity_urgent: "Urgent";
+    readonly automation_role_owner: "Owners";
+    readonly automation_role_editor: "Editors";
+    readonly automation_role_admin: "Admins";
+    readonly automation_role_operator: "Operators";
+    readonly automation_role_view_only: "Viewers";
+    readonly alarm_rule_create_action: "New alarm rule";
+    readonly alarm_rule_create_title: "New alarm rule";
+    readonly alarm_rule_edit_title: "Alarm rule";
+    readonly alarm_rule_create_submit: "Create alarm rule";
+    readonly alarm_rule_create_toast: "Alarm rule created.";
+    readonly alarm_rule_save_toast: "Alarm rule saved.";
+    readonly alarm_rule_new_name: "New alarm";
+    readonly alarm_rule_delete_action: "Delete alarm rule";
+    readonly alarm_rule_delete_confirm_title: "Delete this alarm rule?";
+    readonly alarm_rule_delete_confirm_description: "Its alarm is no longer raised.";
+    readonly alarm_rule_delete_toast: "Alarm rule deleted.";
+    readonly alarm_rule_seconds_invalid: "Enter a number of seconds, such as 30 or 1.5.";
+    readonly alarm_rule_choose: "Choose…";
+    readonly alarm_rule_section_rule: "Rule";
+    readonly alarm_rule_section_inputs: "Inputs";
+    readonly alarm_rule_section_inputs_description: "Name the values the condition and the message use. A calculated input is a formula over the others.";
+    readonly alarm_rule_section_condition: "Condition";
+    readonly alarm_rule_section_message: "Message";
+    readonly alarm_rule_field_name: "Name";
+    readonly alarm_rule_field_description: "Description";
+    readonly alarm_rule_field_severity: "Severity";
+    readonly alarm_rule_field_poll_interval: "Read inputs every (s)";
+    readonly alarm_rule_field_condition: "Raise when";
+    readonly alarm_rule_field_condition_description: "A formula over the inputs, such as level > 90.";
+    readonly alarm_rule_field_hold: "For at least (s)";
+    readonly alarm_rule_field_hold_description: "The condition must hold this long before the alarm is raised.";
+    readonly alarm_rule_field_clear_condition: "Clear when";
+    readonly alarm_rule_field_clear_condition_description: "Optional. Without it, the alarm clears when the condition no longer holds.";
+    readonly alarm_rule_field_clear_hold: "Clear after (s)";
+    readonly alarm_rule_field_optional: "Optional.";
+    readonly alarm_rule_field_latching: "Stays active until acknowledged";
+    readonly alarm_rule_field_latching_description: "The alarm stays active after it clears until someone acknowledges it.";
+    readonly alarm_rule_field_unavailable_after: "Alarm on unknown inputs after (s)";
+    readonly alarm_rule_field_unavailable_after_description: "Optional. Raises a separate alarm when an input stays unknown this long.";
+    readonly alarm_rule_field_title: "Title";
+    readonly alarm_rule_field_title_description: "A message parameter's name in braces is replaced by its value.";
+    readonly alarm_rule_field_body: "Text";
+    readonly alarm_rule_params: "Message parameters";
+    readonly alarm_rule_param_name: "Name";
+    readonly alarm_rule_param_formula: "Formula";
+    readonly alarm_rule_param_add: "Add parameter";
+    readonly alarm_rule_param_remove: "Remove parameter";
+    readonly alarm_rule_param_duplicate: "Two message parameters have the same name.";
+    readonly alarm_rule_param_unnamed: "A message parameter with a formula needs a name.";
+    readonly alarm_rule_field_notify_delay: "Notify after (s)";
+    readonly alarm_rule_field_notify_delay_description: "Notifications wait this long and are not sent if the alarm clears first.";
+    readonly alarm_rule_field_recipients: "Notify";
+    readonly alarm_rule_recipients_default: "Not set";
+    readonly alarm_rule_recipients_roles: "Members with these roles";
+    readonly alarm_rule_recipients_members: "Chosen members";
+    readonly alarm_rule_member_unnamed: "Unnamed member";
+    readonly alarm_rule_member_former: "No longer a member";
+    readonly alarm_rule_recipients_choose: "Choose at least one.";
+    readonly alarm_rule_variable_name: "Name";
+    readonly alarm_rule_variable_kind: "Reads";
+    readonly alarm_rule_variable_parameter: "Parameter";
+    readonly alarm_rule_variable_endpoint: "Endpoint connected";
+    readonly alarm_rule_variable_alarm_rule: "Alarm rule active";
+    readonly alarm_rule_variable_automation_alarm: "Automation alarm active";
+    readonly alarm_rule_variable_automation: "Automation";
+    readonly alarm_rule_variable_alarm_key: "Alarm key";
+    readonly alarm_rule_variable_calc: "Calculated";
+    readonly alarm_rule_variable_formula: "Formula";
+    readonly alarm_rule_variable_add: "Add input";
+    readonly alarm_rule_variable_choose_source: "Choose what this input reads.";
+    readonly alarm_rule_variable_remove: "Remove input";
+    readonly automation_starter_action: "From a starter";
+    readonly automation_starter_title: "Start from a starter";
+    readonly automation_starter_pick_description: "Each starter asks for what it needs, then opens unsaved for you to review and save.";
+    readonly automation_starter_empty: "No starters.";
+    readonly alarm_rule_variable_alarm_state: "Is true while the alarm is";
+    readonly alarm_rule_variable_alarm_state_active: "active";
+    readonly alarm_rule_variable_alarm_state_unacknowledged: "not acknowledged";
+};
+export default _default;

package/dist/src/i18n/catalogs/en/automation-language.d.ts

@@ -0,0 +1,249 @@
+declare const _default: {
+    readonly automation_language_docs: "Docs";
+    readonly automation_language_open_in_setup: "Open in Setup";
+    readonly automation_language_go_to_definition: "Go to definition";
+    readonly automation_language_unknown: "not in this workspace";
+    readonly automation_language_entity_parameter: "Parameter";
+    readonly automation_language_entity_endpoint: "Endpoint";
+    readonly automation_language_entity_alarm_rule: "Alarm rule";
+    readonly automation_language_entity_automation: "Automation";
+    readonly automation_language_entity_member: "Workspace member";
+    readonly automation_language_writable: "writable";
+    readonly automation_language_read_only: "read-only";
+    readonly automation_language_procedure_missing: "No procedure of this automation has this name.";
+    readonly automation_fix_replace: "Change to {value}";
+    readonly automation_fix_add: "Add {value}";
+    readonly automation_fix_remove: "Remove {value}";
+    readonly automation_fix_choose_parameter: "Choose a parameter…";
+    readonly automation_fix_choose_endpoint: "Choose an endpoint…";
+    readonly automation_fix_choose_alarm_rule: "Choose an alarm rule…";
+    readonly automation_fix_choose_automation: "Choose an automation…";
+    readonly automation_fix_choose_member: "Choose a member…";
+    readonly automation_ask_assistant: "Ask the assistant";
+    readonly automation_ask_assistant_message: 'Help me fix a problem in the automation {automation}.\n\nProblem: {problem}\nCode: {code}, path "{path}", line {line}, column {column}\nLine: {excerpt}';
+    readonly automation_outline_label: "Go to a part of the document";
+    readonly automation_outline_placeholder: "Go to…";
+    readonly automation_outline_triggers: "Triggers";
+    readonly automation_outline_variables: "Variables";
+    readonly automation_outline_procedures: "Procedures";
+    readonly automation_outline_fields: "Alarm rule";
+    readonly automation_item_function_if: "The second argument when the condition is true, else the third; only the chosen one runs.";
+    readonly automation_item_function_isKnown: "Whether the value is known: false while an input is stale or unavailable.";
+    readonly automation_item_function_coalesce: "The first known value of its arguments.";
+    readonly automation_item_function_abs: "The absolute value of a number or duration.";
+    readonly automation_item_function_sign: "-1, 0 or 1 by the sign of the number.";
+    readonly automation_item_function_floor: "The number rounded down to a whole number.";
+    readonly automation_item_function_ceil: "The number rounded up to a whole number.";
+    readonly automation_item_function_trunc: "The number with its fraction dropped, towards zero.";
+    readonly automation_item_function_round: "The number rounded to whole numbers or to the given decimals; halves away from zero.";
+    readonly automation_item_function_min: "The smallest of the values, all of one type.";
+    readonly automation_item_function_max: "The largest of the values, all of one type.";
+    readonly automation_item_function_clamp: "The value held between the low and high bounds.";
+    readonly automation_item_function_sqrt: "The square root.";
+    readonly automation_item_function_exp: "e raised to the number.";
+    readonly automation_item_function_ln: "The natural logarithm.";
+    readonly automation_item_function_log10: "The base-10 logarithm.";
+    readonly automation_item_function_pow: "The base raised to the exponent, the same as ^.";
+    readonly automation_item_function_sin: "The sine of an angle in radians.";
+    readonly automation_item_function_cos: "The cosine of an angle in radians.";
+    readonly automation_item_function_tan: "The tangent of an angle in radians.";
+    readonly automation_item_function_asin: "The arcsine, in radians.";
+    readonly automation_item_function_acos: "The arccosine, in radians.";
+    readonly automation_item_function_atan: "The arctangent, in radians.";
+    readonly automation_item_function_atan2: "The angle of the point (x, y), in radians.";
+    readonly automation_item_function_sinh: "The hyperbolic sine.";
+    readonly automation_item_function_cosh: "The hyperbolic cosine.";
+    readonly automation_item_function_tanh: "The hyperbolic tangent.";
+    readonly automation_item_function_asinh: "The inverse hyperbolic sine.";
+    readonly automation_item_function_acosh: "The inverse hyperbolic cosine.";
+    readonly automation_item_function_atanh: "The inverse hyperbolic tangent.";
+    readonly automation_item_function_deg: "Radians converted to degrees.";
+    readonly automation_item_function_rad: "Degrees converted to radians.";
+    readonly automation_item_function_bitAnd: "Bitwise AND of two non-negative whole numbers.";
+    readonly automation_item_function_bitOr: "Bitwise OR of two non-negative whole numbers.";
+    readonly automation_item_function_bitXor: "Bitwise exclusive OR of two non-negative whole numbers.";
+    readonly automation_item_function_shiftLeft: "The bits of the value shifted left.";
+    readonly automation_item_function_shiftRight: "The bits of the value shifted right.";
+    readonly automation_item_function_bit: "Whether a bit of the value is set; bit 0 is the lowest.";
+    readonly automation_item_function_text: "The value as text, or a number with the given decimals.";
+    readonly automation_item_function_number: "The number in a text, or unknown when it is not one.";
+    readonly automation_item_function_len: "The number of characters in a text.";
+    readonly automation_item_function_contains: "Whether a text contains another.";
+    readonly automation_item_function_lower: "The text in lower case.";
+    readonly automation_item_function_upper: "The text in upper case.";
+    readonly automation_item_function_trim: "The text without spaces at its ends.";
+    readonly automation_item_function_formatNumber: "The number with grouped digits.";
+    readonly automation_item_function_formatCurrency: 'An amount in a currency such as "EUR".';
+    readonly automation_item_function_formatPercent: "A fraction as a percentage.";
+    readonly automation_item_function_time: "A time of day from hours, minutes and seconds.";
+    readonly automation_item_function_now: "The current instant.";
+    readonly automation_item_function_timeOfDay: "The wall-clock time in the workspace timezone, now or of an instant.";
+    readonly automation_item_function_weekday: "The weekday, 1 for Monday to 7 for Sunday.";
+    readonly automation_item_function_day: "The day of the month.";
+    readonly automation_item_function_month: "The month, 1 to 12.";
+    readonly automation_item_function_year: "The year.";
+    readonly automation_item_function_sunrise: "Sunrise at the workspace location, today or on an instant's date.";
+    readonly automation_item_function_sunset: "Sunset at the workspace location, today or on an instant's date.";
+    readonly automation_item_operator_or: "True when either side is true.";
+    readonly automation_item_operator_and: "True when both sides are true.";
+    readonly automation_item_operator_not: "True when the value is false.";
+    readonly automation_item_operator_eq: "Whether two values of one type are equal.";
+    readonly automation_item_operator_ne: "Whether two values of one type differ.";
+    readonly automation_item_operator_lt: "Less than.";
+    readonly automation_item_operator_le: "Less than or equal.";
+    readonly automation_item_operator_gt: "Greater than.";
+    readonly automation_item_operator_ge: "Greater than or equal.";
+    readonly automation_item_operator_add: "Adds numbers or durations, moves a time by a duration, or joins texts.";
+    readonly automation_item_operator_sub: "Subtracts; two instants or times of day give a duration.";
+    readonly automation_item_operator_mul: "Multiplies numbers, or a duration by a number.";
+    readonly automation_item_operator_div: "Divides; a duration by a duration gives a number.";
+    readonly automation_item_operator_mod: "The remainder of a division, with the sign of the left side.";
+    readonly automation_item_operator_pow: "Raises to a power, right to left.";
+    readonly automation_item_constant_pi: "The number π.";
+    readonly automation_item_constant_e: "Euler's number e.";
+    readonly automation_item_literal_true: "The boolean true.";
+    readonly automation_item_literal_false: "The boolean false.";
+    readonly automation_item_literal_number: "A number, such as 42, 2.5e-3 or 0xFF.";
+    readonly automation_item_literal_string: "A text in single or double quotes.";
+    readonly automation_item_literal_duration: "A duration, such as 500ms, 30s, 5min, 2h or 1d.";
+    readonly automation_item_literal_timeOfDay: "A time of day, such as 07:30 or 23:59:59.";
+    readonly automation_item_type_number: "A 64-bit floating-point number.";
+    readonly automation_item_type_boolean: "True or false.";
+    readonly automation_item_type_string: "A text.";
+    readonly automation_item_type_instant: "A point in time.";
+    readonly automation_item_type_duration: "A length of time.";
+    readonly automation_item_type_timeOfDay: "A wall-clock time.";
+    readonly automation_item_trigger_inputChange: "Runs when one of the listed input variables changes.";
+    readonly automation_item_trigger_period: "Runs every period.";
+    readonly automation_item_trigger_timeOfDay: "Runs at the given times in the workspace timezone.";
+    readonly automation_item_trigger_sun: "Runs at sunrise or sunset at the workspace location.";
+    readonly automation_item_trigger_alarm: "Runs when an alarm is raised, acknowledged or cleared.";
+    readonly automation_item_trigger_automation: "Runs after each finished run of another automation.";
+    readonly automation_item_trigger_telegram: "Runs when a member sends a command to the Telegram bot.";
+    readonly automation_item_variable_input: "A value the automation reads: a parameter, an endpoint's connection or an alarm.";
+    readonly automation_item_variable_state: "A value that set steps store, kept for the run or between runs.";
+    readonly automation_item_variable_calc: "A formula over other variables, evaluated when read.";
+    readonly automation_item_source_parameter: "Reads a parameter's value.";
+    readonly automation_item_source_endpoint: "Reads whether an endpoint is connected.";
+    readonly automation_item_source_alarm: "Reads whether an alarm is active or not acknowledged.";
+    readonly automation_item_alarmRef_alarmRule: "The alarm of an alarm rule.";
+    readonly automation_item_alarmRef_automation: "An alarm an automation raises under a key.";
+    readonly automation_item_recipients_members: "The chosen workspace members.";
+    readonly automation_item_recipients_roles: "Every member with one of the roles.";
+    readonly automation_item_procedure: "A named list of steps that triggers and call steps run.";
+    readonly automation_item_branch: "A condition and the steps that run while it holds.";
+    readonly automation_item_step_if: "Runs the steps of the first branch whose condition holds, else the else steps.";
+    readonly automation_item_step_call: "Runs another procedure.";
+    readonly automation_item_step_repeat: "Runs its steps a number of times.";
+    readonly automation_item_step_set: "Stores a value in a state variable.";
+    readonly automation_item_step_writeParameter: "Writes a value to a parameter.";
+    readonly automation_item_step_raiseAlarm: "Raises the automation's alarm under a key, or updates it.";
+    readonly automation_item_step_clearAlarm: "Clears the automation's alarm under a key.";
+    readonly automation_item_step_notify: "Notifies workspace members.";
+    readonly automation_item_step_cancelNotify: "Withdraws a delayed notification.";
+    readonly automation_item_step_writeLog: "Writes a line to the automation's log.";
+    readonly automation_item_step_fail: "Ends the run as failed.";
+    readonly automation_item_step_reply: "Answers the member who sent the Telegram command.";
+    readonly automation_item_field_name: "The name, one text or one per language.";
+    readonly automation_item_field_description: "An optional description, one text or one per language.";
+    readonly automation_item_field_pollIntervalMs: "How often every input parameter is read, in milliseconds.";
+    readonly automation_item_field_variables: "The inputs, state and calculated values formulas read by name.";
+    readonly automation_item_field_automation_minRunIntervalMs: "Triggers closer together than this many milliseconds make one run.";
+    readonly automation_item_field_automation_writeLimit: "The most parameter writes allowed in a period.";
+    readonly automation_item_field_automation_triggers: "What starts a run, and the procedure each run starts with.";
+    readonly automation_item_field_automation_procedures: "The named step lists of the automation.";
+    readonly automation_item_field_automation_onInit: "A procedure that runs once when the automation is enabled.";
+    readonly automation_item_field_writeLimit_count: "The most parameter writes in each period.";
+    readonly automation_item_field_writeLimit_periodMs: "The period of the write limit, in milliseconds.";
+    readonly automation_item_field_variable_name: "The name formulas read the variable by.";
+    readonly automation_item_field_variable_input_source: "What the input reads.";
+    readonly automation_item_field_variable_state_type: "The type of the stored value.";
+    readonly automation_item_field_variable_state_lifetime: "Whether the value is kept between runs or only for one run.";
+    readonly automation_item_field_variable_state_initial: "The value at the start, a constant formula; unknown when omitted.";
+    readonly automation_item_field_variable_calc_formula: "The formula that gives the value.";
+    readonly automation_item_field_source_parameter_parameterId: "The parameter to read.";
+    readonly automation_item_field_source_endpoint_endpointId: "The endpoint whose connection to read.";
+    readonly automation_item_field_alarm: "The alarm: of an alarm rule, or an automation's under a key.";
+    readonly automation_item_field_source_alarm_state: "Whether the input is the alarm being active or unacknowledged.";
+    readonly automation_item_field_alarmRef_alarmRuleId: "The alarm rule whose alarm it is.";
+    readonly automation_item_field_alarmRef_automationId: "The automation that raises the alarm.";
+    readonly automation_item_field_alarmRef_key: "The key the automation raises the alarm under.";
+    readonly automation_item_field_trigger_run: "The procedure the run starts with.";
+    readonly automation_item_field_weekdays: "The ISO weekdays, 1 for Monday to 7 for Sunday; every day when omitted.";
+    readonly automation_item_field_trigger_inputChange_inputs: "The input variables whose changes start a run.";
+    readonly automation_item_field_trigger_period_everyMs: "The period, in milliseconds.";
+    readonly automation_item_field_trigger_timeOfDay_times: "The times of day, as HH:MM.";
+    readonly automation_item_field_trigger_sun_event: "Sunrise or sunset.";
+    readonly automation_item_field_trigger_sun_offsetMs: "How long before (negative) or after the event, in milliseconds.";
+    readonly automation_item_field_trigger_alarm_transitions: "The changes of the alarm that start a run.";
+    readonly automation_item_field_trigger_automation_automationId: "The automation whose finished runs start a run.";
+    readonly automation_item_field_trigger_telegram_command: "The bot command, such as /pumps.";
+    readonly automation_item_field_trigger_telegram_minRole: "The lowest role that may run the command; operator when omitted.";
+    readonly automation_item_field_procedure_name: "The name triggers and call steps run the procedure by.";
+    readonly automation_item_field_steps: "The steps, run in order.";
+    readonly automation_item_field_step_if_key: "Identifies the step's state between runs; needed for held and once branches.";
+    readonly automation_item_field_step_if_branches: "The conditions to check in order, each with its steps.";
+    readonly automation_item_field_step_if_else: "The steps to run when no condition holds.";
+    readonly automation_item_field_branch_when: "The condition, a formula giving a boolean.";
+    readonly automation_item_field_branch_heldForMs: "How long the condition must have held, in milliseconds.";
+    readonly automation_item_field_branch_once: "Runs once each time the condition becomes true.";
+    readonly automation_item_field_step_call_procedure: "The procedure to run.";
+    readonly automation_item_field_step_repeat_times: "How many times to run the steps, a formula.";
+    readonly automation_item_field_step_repeat_max: "The most times the steps run.";
+    readonly automation_item_field_step_repeat_counter: "A number state variable set to 1, 2, … before each time.";
+    readonly automation_item_field_step_set_variable: "The state variable to store the value in.";
+    readonly automation_item_field_step_set_value: "The value to store, a formula of the variable's type.";
+    readonly automation_item_field_step_writeParameter_parameterId: "The parameter to write; it must be writable.";
+    readonly automation_item_field_step_writeParameter_value: "The value to write, a formula of the parameter's type.";
+    readonly automation_item_field_step_raiseAlarm_key: "The key of the alarm, which clearAlarm and others use.";
+    readonly automation_item_field_step_clearAlarm_key: "The key of the alarm to clear.";
+    readonly automation_item_field_severity: "How urgent it is: info, warning or urgent.";
+    readonly automation_item_field_message: "The title and body, and the formulas their placeholders show.";
+    readonly automation_item_field_latching: "Stays active after clearing until someone acknowledges it.";
+    readonly automation_item_field_recipients: "Who is notified: chosen members or everyone with a role.";
+    readonly automation_item_field_notifyDelayMs: "How long notifications wait, in milliseconds; dropped if it clears first.";
+    readonly automation_item_field_step_notify_excludeChannels: "External channels not to use; in-app notifications always arrive.";
+    readonly automation_item_field_step_notify_delayMs: "How long the notification waits before it is sent, in milliseconds.";
+    readonly automation_item_field_step_notify_cancelKey: "A key cancelNotify can withdraw the notification by while it waits.";
+    readonly automation_item_field_step_cancelNotify_cancelKey: "The cancel key of the notification to withdraw.";
+    readonly automation_item_field_step_writeLog_level: "The level of the log line.";
+    readonly automation_item_field_step_writeLog_message: "The line to write, a formula.";
+    readonly automation_item_field_step_fail_message: "Why the run failed.";
+    readonly automation_item_field_message_title: "The title, with placeholders in braces.";
+    readonly automation_item_field_message_body: "The body, with placeholders in braces.";
+    readonly automation_item_field_message_params: "A formula for each placeholder of the title and body.";
+    readonly automation_item_field_recipients_members_userIds: "The members to notify.";
+    readonly automation_item_field_recipients_roles_roles: "The roles whose members are notified.";
+    readonly automation_item_field_alarmRule_condition: "Raises the alarm while it holds, a formula giving a boolean.";
+    readonly automation_item_field_alarmRule_holdMs: "How long the condition must hold before the alarm is raised, in milliseconds.";
+    readonly automation_item_field_alarmRule_clearCondition: "Clears the alarm while it holds; not condition when omitted.";
+    readonly automation_item_field_alarmRule_clearHoldMs: "How long the clear condition must hold, in milliseconds.";
+    readonly automation_item_field_alarmRule_latching: "Keeps the alarm active after it clears until someone acknowledges it.";
+    readonly automation_item_field_alarmRule_notifyDelayMs: "How long notifications wait, in milliseconds; dropped if the alarm clears first.";
+    readonly automation_item_field_alarmRule_unavailableAfterMs: "Raises a separate alarm when an input stays unknown this long.";
+    readonly automation_item_value_severity_info: "For information.";
+    readonly automation_item_value_severity_warning: "Needs attention.";
+    readonly automation_item_value_severity_urgent: "Needs action now.";
+    readonly automation_item_value_channel_email: "Email.";
+    readonly automation_item_value_channel_sms: "Text message.";
+    readonly automation_item_value_channel_telegram: "Telegram.";
+    readonly automation_item_value_role_owner: "Owners of the workspace.";
+    readonly automation_item_value_role_admin: "Admins.";
+    readonly automation_item_value_role_editor: "Editors.";
+    readonly automation_item_value_role_operator: "Operators.";
+    readonly automation_item_value_role_view_only: "Members who only view.";
+    readonly automation_item_value_lifetime_run: "Starts again in every run.";
+    readonly automation_item_value_lifetime_automation: "Kept between runs and restarts.";
+    readonly automation_item_value_level_debug: "Detail for finding problems.";
+    readonly automation_item_value_level_info: "Normal information.";
+    readonly automation_item_value_level_warn: "Something to look at.";
+    readonly automation_item_value_level_error: "Something went wrong.";
+    readonly automation_item_value_sunEvent_sunrise: "Sunrise.";
+    readonly automation_item_value_sunEvent_sunset: "Sunset.";
+    readonly automation_item_value_transition_raised: "The alarm is raised.";
+    readonly automation_item_value_transition_acknowledged: "The alarm is acknowledged.";
+    readonly automation_item_value_transition_cleared: "The alarm clears.";
+    readonly automation_item_value_alarmState_active: "Raised and not cleared.";
+    readonly automation_item_value_alarmState_unacknowledged: "Raised and not acknowledged yet, also after a latching alarm cleared.";
+};
+export default _default;

package/dist/src/i18n/catalogs/en/automation.d.ts

@@ -0,0 +1,59 @@
+declare const _default: {
+    readonly automation_diagnostic_invalid_shape: "This part does not match the format.";
+    readonly automation_diagnostic_duplicate_name: "{name} is declared more than once.";
+    readonly automation_diagnostic_reserved_name: "{name} is a reserved word.";
+    readonly automation_diagnostic_unknown_procedure: "There is no procedure {name}.";
+    readonly automation_diagnostic_recursive_call: "Procedures call each other in a loop: {cycle}.";
+    readonly automation_diagnostic_unknown_variable: "There is no variable {name}.";
+    readonly automation_diagnostic_not_an_input: "{name} is not an input variable.";
+    readonly automation_diagnostic_not_a_state_variable: "{name} is not a state variable.";
+    readonly automation_diagnostic_state_not_allowed: "Alarm rules cannot have state variables such as {name}.";
+    readonly automation_diagnostic_variable_type: "{name} has type {actual}. Expected: {expected}.";
+    readonly automation_diagnostic_calc_cycle: "Calculated variables depend on each other in a loop: {cycle}.";
+    readonly automation_diagnostic_unknown_parameter: "The parameter is not in this workspace.";
+    readonly automation_diagnostic_unknown_endpoint: "The endpoint is not in this workspace.";
+    readonly automation_diagnostic_unknown_alarm: "The alarm rule is not in this workspace.";
+    readonly automation_diagnostic_unknown_alarm_key: "No alarm {key} is raised there.";
+    readonly automation_diagnostic_unknown_automation: "The automation is not in this workspace.";
+    readonly automation_diagnostic_unknown_member: "This user is not a member of the workspace.";
+    readonly automation_diagnostic_unknown_cancel_key: "No notification uses the cancel key {key}.";
+    readonly automation_diagnostic_parameter_not_writable: "This parameter cannot be written.";
+    readonly automation_diagnostic_parameter_disabled: "This parameter is disabled, so its value is unavailable until it is enabled.";
+    readonly automation_diagnostic_key_required: "A branch that waits or runs once needs a key on its step.";
+    readonly automation_diagnostic_duplicate_key: "The key {key} is used more than once.";
+    readonly automation_diagnostic_unknown_placeholder: "The placeholder {name} has no parameter.";
+    readonly automation_diagnostic_unused_param: "The parameter {name} is not used in the text.";
+    readonly automation_diagnostic_unused_procedure: "Nothing runs the procedure {name}.";
+    readonly automation_diagnostic_steps_over_limit: "A run can take up to {steps} steps; the workspace allows {limit}.";
+    readonly automation_diagnostic_interval_under_limit: "{interval} s is shorter than the workspace minimum of {limit} s.";
+    readonly automation_diagnostic_write_rate_over_limit: "{rate} writes per minute is more than the workspace allows ({limit}).";
+    readonly automation_diagnostic_automation_trigger_cycle: "Automations would trigger each other in a loop: {cycle}.";
+    readonly automation_diagnostic_location_missing: "Sunrise and sunset need the workspace location. Set it in the workspace settings.";
+    readonly automation_diagnostic_reserved_command: "{command} is a command of the Telegram bot itself. Choose another command.";
+    readonly automation_diagnostic_reply_without_command: "Only procedures a Telegram command runs can reply.";
+    readonly automation_shape_missing: "Add {properties}.";
+    readonly automation_shape_unexpected: "Remove {properties}; it is not part of the format.";
+    readonly automation_shape_type: "Expected: {expected}.";
+    readonly automation_shape_too_few: "At least {limit} items are needed.";
+    readonly automation_shape_too_many: "At most {limit} items are allowed.";
+    readonly automation_shape_too_short: "Enter at least {limit} characters.";
+    readonly automation_shape_too_long: "Use at most {limit} characters.";
+    readonly automation_shape_too_small: "Use {limit} or more.";
+    readonly automation_shape_too_large: "Use {limit} or less.";
+    readonly automation_shape_allowed: "Use one of: {values}.";
+    readonly automation_shape_kind: "Unknown kind. Use one of: {values}.";
+    readonly automation_shape_duplicate: "Remove the repeated item.";
+    readonly automation_shape_format_uuid: "Use an ID such as 3f2b0c1e-…";
+    readonly automation_shape_format_other: "This value must be in the {format} format.";
+    readonly automation_shape_form_name: "Use letters, digits and _, starting with a letter or _, at most 40 characters.";
+    readonly automation_shape_form_key: "Use lowercase letters, digits and -, starting with a letter, at most 40 characters.";
+    readonly automation_shape_form_time: "Use a time as HH:MM, for example 07:30.";
+    readonly automation_shape_form_command: "Use a command such as /pumps: / and up to 32 lowercase letters, digits or _.";
+    readonly automation_shape_form_language: "Use a two-letter language code such as en.";
+    readonly automation_shape_form_other: "This value has the wrong form.";
+    readonly automation_json_integer: "whole number";
+    readonly automation_json_array: "list";
+    readonly automation_json_object: "set of fields";
+    readonly automation_json_null: "nothing";
+};
+export default _default;

package/dist/src/i18n/catalogs/en/brand.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    readonly brand_name: "Overvis HMI";
+};
+export default _default;

package/dist/src/i18n/catalogs/en/cold-room.d.ts

@@ -0,0 +1,26 @@
+declare const _default: {
+    readonly cold_room_setpoint: "Setpoint";
+    readonly cold_room_evaporator: "Evaporator";
+    readonly cold_room_auxiliary: "Auxiliary probe";
+    readonly cold_room_alarm_limits: "Alarm limits";
+    readonly cold_room_compressor: "Compressor";
+    readonly cold_room_defrost: "Defrost";
+    readonly cold_room_fans: "Fans";
+    readonly cold_room_door: "Door";
+    readonly cold_room_door_open: "Open";
+    readonly cold_room_door_closed: "Closed";
+    readonly cold_room_status_standby: "Stand-by";
+    readonly cold_room_status_defrost: "Defrosting";
+    readonly cold_room_status_cooling: "Cooling";
+    readonly cold_room_status_heating: "Heating";
+    readonly cold_room_status_idle: "Idle";
+    readonly cold_room_states: "Equipment state";
+    readonly cold_room_alarms: "Alarms";
+    readonly cold_room_no_alarms: "No active alarms";
+    readonly cold_room_commands: "Commands";
+    readonly cold_room_command_defrost: "Start defrost";
+    readonly cold_room_command_on: "Switch on";
+    readonly cold_room_command_off: "Switch to stand-by";
+    readonly cold_room_commands_need_reading: "Commands are available once the room temperature reading is current.";
+};
+export default _default;

package/dist/src/i18n/catalogs/en/copyable.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    readonly copyable_id_copy: "Copy id";
+    readonly copyable_id_copied: "Copied";
+    readonly copyable_id_copy_failed: "Could not copy to the clipboard.";
+};
+export default _default;