@antelopejs/dms 0.9.8 → 0.11.0

package/frontend-vue/layers/dms-core/app/composables/useFieldErrors.ts

@@ -1,5 +1,8 @@
 import { nextTick, reactive } from "vue";
-import { resolveApiMessage } from "./translation/useTranslation";
+import {
+  type I18nTranslate,
+  resolveApiMessage,
+} from "./translation/useTranslation";
 import { resolveApiErrorMessage } from "./useApiError";
 
 /**
@@ -116,24 +119,23 @@ const FIELD_ERROR_KEYS = {
 /** Issue types whose size is a count (characters, items), not a value. */
 const COUNTED_TYPES = new Set(["string", "array", "set"]);
 
-// The data API (`@antelopejs/interface-data-api`) words its refusals in
-// English and lists the fields after a colon.
-const DATA_API_MESSAGES: ReadonlyArray<{ pattern: RegExp; message: string }> = [
-  {
-    pattern: /^Missing mandatory fields:\s*(.+)$/,
-    message: FIELD_ERROR_KEYS.required,
-  },
-  {
-    pattern: /^Invalid field type\(s\):\s*(.+)$/,
-    message: FIELD_ERROR_KEYS.invalid,
-  },
-];
+// The codes the data API (`@antelopejs/interface-data-api`) refuses a body
+// with, `{ code, fields }`: the message each field shows.
+const DATA_API_CODES: Readonly<Record<string, string>> = {
+  missing_mandatory_fields: FIELD_ERROR_KEYS.required,
+  invalid_field_types: FIELD_ERROR_KEYS.invalid,
+};
+
+// The same, naming the field: "Loss reason is required".
+const NAMED_FIELD_ERROR_KEYS: Readonly<Record<string, string>> = {
+  [FIELD_ERROR_KEYS.required]: "dms.field_errors.named_required",
+  [FIELD_ERROR_KEYS.invalid]: "dms.field_errors.named_invalid",
+};
 
 // `name: String must contain…`: one validation issue prefixed with its field.
 const FIELD_PREFIXED_MESSAGE = /^([\w.]+):\s+(.+)$/s;
 // `error.invalid_2fa_code`, `page.settings.roles.error.name_taken`.
 const BARE_I18N_KEY = /^[a-z0-9_]+(\.[a-z0-9_]+)+$/i;
-const LIST_SEPARATOR = /\s*,\s*/;
 
 /** The HTTP status of a fetch error; undefined for a network failure. */
 export function apiErrorStatus(error: unknown): number | undefined {
@@ -265,16 +267,19 @@ function fromFieldObject(body: Record<string, unknown>): ApiFieldError[] {
   ];
 }
 
+/** `{ code, fields }`, the data API's refusal of a body; undefined otherwise. */
+function fromCodedFields(
+  body: Record<string, unknown>,
+): ApiFieldError[] | undefined {
+  const { code, fields } = body;
+  const message = typeof code === "string" ? DATA_API_CODES[code] : undefined;
+  if (!message || !Array.isArray(fields)) return undefined;
+  return fields
+    .filter((field): field is string => typeof field === "string")
+    .map((field) => ({ field, message }));
+}
+
 function fromText(text: string): ApiFieldError[] {
-  for (const { pattern, message } of DATA_API_MESSAGES) {
-    const match = pattern.exec(text);
-    if (match) {
-      return match[1]!
-        .split(LIST_SEPARATOR)
-        .filter(Boolean)
-        .map((field) => ({ field, message }));
-    }
-  }
   const prefixed = FIELD_PREFIXED_MESSAGE.exec(text);
   if (prefixed) {
     const [, field, message] = prefixed;
@@ -320,7 +325,7 @@ function fromBody(body: unknown): ApiFieldError[] {
   const record = body as Record<string, unknown>;
   if (isIssueList(record.issues)) return fromIssues(record.issues);
   if (isIssueList(record.errors)) return fromIssues(record.errors);
-  return fromFieldObject(record);
+  return fromCodedFields(record) ?? fromFieldObject(record);
 }
 
 function isClientError(status: number | undefined): status is number {
@@ -337,8 +342,8 @@ function isClientError(status: number | undefined): status is number {
  *
  * Read, in order: a code the form maps to a field (`codes`, for any 4xx), a
  * zod issue list (what `assertValidation` answers), a `{ field, message }`
- * body (with optional `values` and `params`), the data API's "Missing mandatory fields: a, b" / "Invalid field
- * type(s): a" and a `field: message` text. A network failure, a 403, a 429
+ * body (with optional `values` and `params`), the data API's
+ * `{ code, fields }` and a `field: message` text. A network failure, a 403, a 429
  * or a 5xx never resolves to a field.
  *
  * @returns The field errors, one per field (the first issue wins), and
@@ -371,6 +376,36 @@ export function resolveFieldErrors<F extends string>(
   return { fields, hasUnmatched: hasUnmatched || fields.length === 0 };
 }
 
+/**
+ * The data API's refusal of a body (`{ code, fields }`) as one sentence per
+ * field naming it, translated: "Loss reason is required." Undefined for any
+ * other error. `labelOf` gives a field's label, translated; the field's id
+ * stands in for one it does not know.
+ */
+export function describeFieldErrors(
+  error: unknown,
+  translate: I18nTranslate,
+  labelOf: (field: string) => string | undefined,
+): string | undefined {
+  const status = apiErrorStatus(error);
+  if (status === undefined || !VALIDATION_STATUSES.has(status)) {
+    return undefined;
+  }
+  const body = bodyOf(error);
+  if (typeof body !== "object" || body === null || Array.isArray(body)) {
+    return undefined;
+  }
+  const entries = fromCodedFields(body as Record<string, unknown>);
+  if (!entries?.length) return undefined;
+  return entries
+    .map(({ field, message }) =>
+      translate(NAMED_FIELD_ERROR_KEYS[message]!, {
+        field: labelOf(field) ?? field,
+      }),
+    )
+    .join(" ");
+}
+
 /**
  * The message of an error that belongs to no field, for its toast: the API's
  * message key, the first validation issue's (or a generic one), else the

package/frontend-vue/layers/dms-core/app/plugins/dev-error-log.ts

@@ -0,0 +1,16 @@
+import { defineDmsPlugin } from "#dms/frontend-module";
+
+/**
+ * Logs, in development, every error Vue catches before the renderer's own
+ * handler takes it. That handler only keeps the error for the error page, so
+ * a render that throws showed its bare message there ("ERROR 500 · Must be
+ * called at the top of a `setup` function") with no stack in any console.
+ */
+export default defineDmsPlugin(({ vueApp }) => {
+  if (!import.meta.env.DEV) return;
+  const handleError = vueApp.config.errorHandler;
+  vueApp.config.errorHandler = (error, instance, info) => {
+    console.error(`[dms] Uncaught error (${info})`, error);
+    handleError?.(error, instance, info);
+  };
+});

package/frontend-vue/layers/dms-core/app/types/user.ts

@@ -1,3 +1,8 @@
+/** A stored profile picture: the file's resource key. */
+export interface UserAvatar {
+  key: string;
+}
+
 export interface User {
   _id: string;
   createdAt: Date;
@@ -6,4 +11,5 @@ export interface User {
   name: string;
   language: string;
   isValidated: boolean;
+  avatar?: UserAvatar | null;
 }

package/frontend-vue/layers/dms-core/app/utils/composedText.ts

@@ -15,7 +15,12 @@ import {
   readTranslationKey,
   resolveI18nKey,
 } from "../composables/translation/useTranslation";
-import { formatDate, formatNumber, formatRelativeDistance } from "./formatter";
+import {
+  formatDate,
+  formatNumber,
+  formatRelativeDistance,
+  readableNumberFormat,
+} from "./formatter";
 
 /** `t` as vue-i18n takes it: the key, the named values, the plural count. */
 export type ComposedTextTranslate = (
@@ -103,7 +108,7 @@ function formatMoney(
   { locale }: ComposedTextContext,
 ): string {
   try {
-    const format = new Intl.NumberFormat(locale, {
+    const format = readableNumberFormat(locale, {
       style: "currency",
       currency: param.currency,
     });

package/frontend-vue/layers/dms-core/app/utils/formatter.ts

@@ -20,8 +20,6 @@ const TIME_UNITS = {
   ms: 1,
 } as const;
 
-const TIME_UNIT_ORDER = ["y", "M", "w", "d", "h", "m", "s", "ms"] as const;
-
 type TranslateFunction = (
   key: string,
   params?: Record<string, unknown>,
@@ -230,8 +228,23 @@ export function formatDateTime(
 }
 
 /**
- * A number written for `locale`; a value that is not a number is returned as
- * is. Options Intl refuses (an unknown currency) write the bare number.
+ * `new Intl.NumberFormat(locale, options)` the way the interface writes a
+ * figure: a four-digit one grouped like a longer one ("1 234" next to
+ * "12 345", where Spanish or Polish would leave "1234" by default).
+ * `options.useGrouping` still decides. Throws as `Intl.NumberFormat` does on
+ * options it refuses.
+ */
+export function readableNumberFormat(
+  locale?: string,
+  options?: Intl.NumberFormatOptions,
+): Intl.NumberFormat {
+  return new Intl.NumberFormat(locale, { useGrouping: true, ...options });
+}
+
+/**
+ * A number written for `locale` (see {@link readableNumberFormat}); a value
+ * that is not a number is returned as is. Options Intl refuses (an unknown
+ * currency) write the bare number.
  */
 export function formatNumber(
   value: number,
@@ -250,7 +263,7 @@ export function formatNumber(
 ): unknown {
   if (!isNumber(value)) return value;
   try {
-    return new Intl.NumberFormat(locale, options).format(value);
+    return readableNumberFormat(locale, options).format(value);
   } catch {
     return String(value);
   }
@@ -312,16 +325,19 @@ const TIME_SPAN_UNITS: Record<string, keyof typeof TIME_UNITS> = {
   w: "w",
   d: "d",
   h: "h",
+  min: "m",
   m: "m",
   s: "s",
   ms: "ms",
 };
 
-// `01:30`, `26:00:30`: hours, then minutes and seconds under 60.
+// `01:30`, `8:15`, `26:00:30`: hours, then minutes and seconds under 60.
 const CLOCK_SPAN = /^(\d+):([0-5]\d)(?::([0-5]\d))?$/;
-// `1h30m`, `1h 30m`, `1h:30m` (what `formatTimeSpan` writes), `1.5h`.
-const UNIT_SPAN = /^(?:\d+(?:\.\d+)?(?:ms|mo|[Mmwydhs])[\s:]*)+$/;
-const UNIT_SPAN_PART = /(\d+(?:\.\d+)?)(ms|mo|[Mmwydhs])/g;
+// `8h15`, `8 h 05`: hours, then bare minutes, the way a time is often written.
+const HOUR_MINUTE_SPAN = /^(\d+)\s*h\s*([0-5]?\d)$/i;
+// `1h30m`, `1h 30m`, `7 h 30 min`, `1h:30m` (older displays), `1.5h`.
+const UNIT_SPAN = /^(?:\d+(?:[.,]\d+)?\s*(?:ms|mo|min|[Mmwydhs])[\s:]*)+$/;
+const UNIT_SPAN_PART = /(\d+(?:[.,]\d+)?)\s*(ms|mo|min|[Mmwydhs])/g;
 
 function readClockSpan(text: string): number | undefined {
   const match = CLOCK_SPAN.exec(text);
@@ -334,24 +350,38 @@ function readClockSpan(text: string): number | undefined {
   );
 }
 
+function readHourMinuteSpan(text: string): number | undefined {
+  const match = HOUR_MINUTE_SPAN.exec(text);
+  if (!match) return undefined;
+  const [, hours, minutes] = match;
+  return Number(hours) * TIME_UNITS.h + Number(minutes) * TIME_UNITS.m;
+}
+
 function readUnitSpan(text: string): number | undefined {
   if (!UNIT_SPAN.test(text)) return undefined;
   let total = 0;
   for (const [, amount, unit] of text.matchAll(UNIT_SPAN_PART)) {
-    total += Number.parseFloat(amount!) * TIME_UNITS[TIME_SPAN_UNITS[unit!]!];
+    const value = Number.parseFloat(amount!.replace(",", "."));
+    total += value * TIME_UNITS[TIME_SPAN_UNITS[unit!]!];
   }
   return total;
 }
 
 /**
- * A duration typed in, in milliseconds: a clock duration (`01:30`,
- * `26:00:30`) or units (`1h30m`, `1h 30m`, `1.5h`), or `undefined` for a
- * text that is neither.
+ * A duration typed in, in milliseconds: a clock duration (`01:30`, `8:15`,
+ * `26:00:30`), hours then minutes (`8h15`, `8h`) or units (`1h30m`,
+ * `1h 30m`, `7 h 30 min`, `1.5h`), a `-` before any of them for a negative
+ * one, or `undefined` for a text that is neither. It reads all
+ * {@link formatDuration} writes.
  */
 export function readTimeSpan(value: string): number | undefined {
-  const text = value.trim();
+  const trimmed = value.trim();
+  const isNegative = trimmed.startsWith("-");
+  const text = isNegative ? trimmed.slice(1).trimStart() : trimmed;
   if (!text) return undefined;
-  return readClockSpan(text) ?? readUnitSpan(text);
+  const span =
+    readClockSpan(text) ?? readHourMinuteSpan(text) ?? readUnitSpan(text);
+  return span !== undefined && isNegative ? -span : span;
 }
 
 export function parseTimeSpan(value: string | number): number {
@@ -359,30 +389,99 @@ export function parseTimeSpan(value: string | number): number {
   return readTimeSpan(value) ?? 0;
 }
 
-const DEFAULT_SEPARATOR = ":";
-const ZERO_MS = "0ms";
+// Durations count in hours at most: a day or a month is a calendar span, not
+// a number of hours.
+const DURATION_UNITS = [
+  { symbol: "h", ms: TIME_UNITS.h, fractionDigits: 0 },
+  { symbol: "min", ms: TIME_UNITS.m, fractionDigits: 0 },
+  // The seconds carry the milliseconds, so nothing is rounded away.
+  { symbol: "s", ms: TIME_UNITS.s, fractionDigits: 3 },
+] as const;
+const MS_FRACTION_DIGITS = 3;
 
-export function formatTimeSpan(
-  ms: unknown,
-  separator: string = DEFAULT_SEPARATOR,
-): string {
-  if (!isNumber(ms)) return String(ms);
+/**
+ * How exact a written duration is: `exact` (the default) keeps every
+ * millisecond, so a field shows the value it holds and {@link readTimeSpan}
+ * reads it back; `rounded` keeps two units at most, the smaller one rounded
+ * ("2.1 s", "4 min 12 s", "7 h 30 min"), for a cell read at a glance.
+ */
+export type DurationPrecision = "exact" | "rounded";
+
+export interface DurationFormatOptions {
+  precision?: DurationPrecision;
+}
 
-  const totalMs = Number(ms);
-  if (totalMs === 0) return ZERO_MS;
+const ROUNDED_SECONDS_FRACTION_DIGITS = 1;
 
+function durationFigure(
+  locale: string,
+  value: number,
+  symbol: string,
+  fractionDigits: number,
+): string {
+  const figure = readableNumberFormat(locale, {
+    maximumFractionDigits: fractionDigits,
+    useGrouping: false,
+    numberingSystem: "latn",
+  }).format(value);
+  return `${figure} ${symbol}`;
+}
+
+function exactDuration(ms: number, locale: string): string {
+  let remaining = ms;
+  if (remaining < TIME_UNITS.s) {
+    return durationFigure(locale, remaining, "ms", MS_FRACTION_DIGITS);
+  }
   const parts: string[] = [];
-  let remaining = Math.abs(totalMs);
-
-  for (const unit of TIME_UNIT_ORDER) {
-    const unitValue = TIME_UNITS[unit];
-    if (remaining >= unitValue) {
-      const value = Math.floor(remaining / unitValue);
-      parts.push(`${value}${unit}`);
-      remaining %= unitValue;
-    }
+  for (const { symbol, ms: unitMs, fractionDigits } of DURATION_UNITS) {
+    const amount = fractionDigits
+      ? remaining / unitMs
+      : Math.floor(remaining / unitMs);
+    remaining -= amount * unitMs;
+    if (amount)
+      parts.push(durationFigure(locale, amount, symbol, fractionDigits));
   }
+  return parts.join(" ");
+}
 
-  const formatted = parts.join(separator);
-  return totalMs < 0 ? `-${formatted}` : formatted;
+function roundedDuration(ms: number, locale: string): string {
+  if (ms < TIME_UNITS.s) return durationFigure(locale, Math.round(ms), "ms", 0);
+  if (ms < TIME_UNITS.m) {
+    return durationFigure(
+      locale,
+      ms / TIME_UNITS.s,
+      "s",
+      ROUNDED_SECONDS_FRACTION_DIGITS,
+    );
+  }
+  const [major, majorSymbol, minor, minorSymbol] =
+    ms < TIME_UNITS.h
+      ? ([TIME_UNITS.m, "min", TIME_UNITS.s, "s"] as const)
+      : ([TIME_UNITS.h, "h", TIME_UNITS.m, "min"] as const);
+  // Rounded as a whole first, so 1 min 59.7 s reads "2 min", not "1 min 60 s".
+  const total = Math.round(ms / minor) * minor;
+  const whole = Math.floor(total / major);
+  const rest = (total - whole * major) / minor;
+  const head = durationFigure(locale, whole, majorSymbol, 0);
+  return rest
+    ? `${head} ${durationFigure(locale, rest, minorSymbol, 0)}`
+    : head;
+}
+
+/**
+ * A duration in milliseconds the way people write it, its figures in the
+ * reader's locale: "910 ms", "2.149 s", "4 min 12 s", "7 h 30 min". The one
+ * writer of a duration, for a field and a cell alike. Exact by default (hours
+ * and minutes whole, the seconds carrying the milliseconds), its figures
+ * neither grouped nor in another script, so {@link readTimeSpan} reads back
+ * the very value it wrote; `precision: "rounded"` for a cell.
+ */
+export function formatDuration(
+  ms: number,
+  locale: string,
+  { precision = "exact" }: DurationFormatOptions = {},
+): string {
+  const sign = ms < 0 ? "-" : "";
+  const write = precision === "rounded" ? roundedDuration : exactDuration;
+  return sign + write(Math.abs(ms), locale);
 }

package/frontend-vue/layers/dms-core/app/utils/url-interpolation.ts

@@ -12,8 +12,25 @@ const WHOLE_ROW_TOKEN = new RegExp(`^\\s*${ROW_TOKEN.source}\\s*$`);
 export const namesRowField = (template: string): boolean =>
   new RegExp(ROW_TOKEN.source).test(template);
 
+// A relation field is listed as the related row (a join): it stands for that
+// row's id, as the field stores it, rather than "[object Object]". A dotted
+// path (`{{row.customer.name}}`) still reaches into the row.
+const RELATED_ROW_ID_KEYS = ["_id", "id"] as const;
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  Object.prototype.toString.call(value) === "[object Object]";
+
+const relatedRowId = (value: Record<string, unknown>): unknown =>
+  RELATED_ROW_ID_KEYS.map((key) => value[key]).find(
+    (id) => id !== undefined && id !== null,
+  );
+
+const scalarOf = (value: unknown): unknown =>
+  isPlainObject(value) ? relatedRowId(value) : value;
+
 const rowValue = (data: Record<string, unknown>, key: string): string => {
-  const value: unknown = get(data, key);
+  const field: unknown = get(data, key);
+  const value = Array.isArray(field) ? field.map(scalarOf) : scalarOf(field);
   return value === undefined || value === null ? "" : String(value);
 };
 

package/frontend-vue/layers/dms-core/i18n/locales/core-en-GB.json

@@ -408,6 +408,8 @@
       "too_short": "This value is too short.",
       "too_small": "This value is too small.",
       "too_large": "This value is too large.",
+      "named_required": "{field} is required.",
+      "named_invalid": "{field} is not valid.",
       "with_values": "{message}: {values}",
       "code_incomplete": "Enter every digit of the code.",
       "password_rules": "The password doesn’t meet every rule.",
@@ -438,7 +440,8 @@
     "chart": {
       "no_data": "No data",
       "legend_period": "Period",
-      "legend_comparison": "Comparison"
+      "legend_comparison": "Comparison",
+      "versus_value": "vs {value}"
     },
     "period": {
       "aria_label": "Period selector",
@@ -463,12 +466,33 @@
         "all": "All time",
         "custom": "Custom"
       },
+      "short_presets": {
+        "last-hour": "1H",
+        "last-24h": "24H",
+        "today": "1D",
+        "yesterday": "-1D",
+        "last-7-days": "7D",
+        "last-30-days": "30D",
+        "last-90-days": "90D",
+        "this-month": "MTD",
+        "last-month": "-1M",
+        "this-quarter": "QTD",
+        "last-quarter": "-1Q",
+        "ytd": "YTD",
+        "last-year": "-1Y",
+        "all": "ALL"
+      },
       "comparisons": {
         "none": "No comparison",
         "previous-period": "vs previous period",
         "previous-year": "vs previous year",
         "custom": "Custom"
       },
+      "compare_labels": {
+        "previous-period": "vs previous period",
+        "previous-year": "vs previous year",
+        "custom": "vs comparison period"
+      },
       "compare_options": {
         "none": "No comparison",
         "previous-period": "Previous period",
@@ -494,7 +518,117 @@
     },
     "a11y": {
       "breadcrumb": "Breadcrumb",
-      "loading": "Loading"
+      "close": "Close",
+      "loading": "Loading",
+      "show_options": "Show options"
+    },
+    "automation": {
+      "triggers": {
+        "memberAdded": {
+          "name": "Member added",
+          "description": "Fires when a user becomes a member of a workspace"
+        },
+        "memberRemoved": {
+          "name": "Member removed",
+          "description": "Fires when members are removed from a workspace"
+        },
+        "inviteCreated": {
+          "name": "Invite created",
+          "description": "Fires when a user invite is created on a workspace"
+        },
+        "userRegistered": {
+          "name": "User registered",
+          "description": "Fires when a new user completes signup"
+        },
+        "recordCreated": {
+          "name": "Record created",
+          "description": "Fires when rows are created in a TableView-backed table"
+        },
+        "recordUpdated": {
+          "name": "Record updated",
+          "description": "Fires when rows are updated in a TableView-backed table"
+        },
+        "recordDeleted": {
+          "name": "Record deleted",
+          "description": "Fires when rows are deleted in a TableView-backed table"
+        },
+        "record": {
+          "fields": {
+            "location": "Data controller location to watch, e.g. \"/api/tables/members\". Leave empty to fire for every table."
+          }
+        }
+      },
+      "actions": {
+        "sendEmail": {
+          "name": "Send email",
+          "description": "Send an HTML email through the configured email provider, written out or rendered from a registered HTML template",
+          "fields": {
+            "template": "Name of a registered HTML template to render instead of the HTML",
+            "props": "Props the template is rendered with",
+            "language": "Language the template is rendered in; defaults to the recipient's when the address belongs to a user"
+          }
+        },
+        "sendNotification": {
+          "name": "Send notification",
+          "description": "Send an in-app notification to specific users and/or every user holding one of the given roles",
+          "fields": {
+            "userId": "One recipient, e.g. a trigger's user ID",
+            "tenantId": "Workspace whose members receive the role notification; leave empty for the default workspace",
+            "title": "Literal text, or a \"$\" translation key",
+            "description": "Literal text, or a \"$\" translation key",
+            "params": "Interpolation params of the title and description translations",
+            "idempotencyKey": "Stable event key, e.g. a trigger's delivery ID: a replayed event is delivered once"
+          }
+        },
+        "inviteUser": {
+          "name": "Invite user",
+          "description": "Invite an email address to a workspace: existing users are added as members directly, otherwise an invite is created (and its signup email sent unless Send the email is off)",
+          "fields": {
+            "tenantId": "Workspace to invite into; defaults to the default workspace",
+            "language": "Language of the invitation email and of the account it creates; defaults to en",
+            "inviterName": "Who the invitation email says it comes from"
+          }
+        }
+      },
+      "fields": {
+        "actorId": "Actor ID",
+        "actorName": "Actor name",
+        "asTenantOwner": "Workspace owner",
+        "at": "Date",
+        "deliveryId": "Delivery ID",
+        "description": "Description",
+        "email": "Email",
+        "error": "Error",
+        "firstname": "First name",
+        "html": "HTML",
+        "icon": "Icon",
+        "idempotencyKey": "Replay key",
+        "ids": "Record IDs",
+        "inviteId": "Invite ID",
+        "inviterName": "Inviter name",
+        "isTenantOwner": "Workspace owner",
+        "kind": "Result",
+        "language": "Language",
+        "lastname": "Last name",
+        "linkTo": "Link",
+        "location": "Table",
+        "messageId": "Message ID",
+        "name": "Name",
+        "ok": "Sent",
+        "params": "Parameters",
+        "props": "Template props",
+        "roleIds": "Roles",
+        "sendEmail": "Send the email",
+        "subject": "Subject",
+        "success": "Success",
+        "template": "Template",
+        "tenantId": "Workspace",
+        "title": "Title",
+        "to": "To",
+        "tone": "Tone",
+        "userId": "User",
+        "userIds": "Users"
+      }
     }
   }
 }