@evotecit/canopyx 0.3.5 → 0.3.6

package/JavaScript/flow.d.ts

@@ -2,12 +2,18 @@
 // proposal to the host. The flow entry point (@evotecit/canopyx/flow) and the grid entry points create them.
 import type { CanopyPlugin } from "./plugins.js";
 
-/** A value a field holds: text, a number, a boolean, a list of values, or nothing. Secrets never have one. */
-export type FlowValue = string | number | boolean | null | readonly (string | number | boolean)[];
+/** A value a field holds: text, a number, a boolean, a list of values, rows of a records field, picked records, or nothing. Secrets never have one. */
+export type FlowValue = string | number | boolean | null | readonly (string | number | boolean)[] | readonly FlowRecordRow[] | readonly FlowPickedRecord[];
+
+/** A row of a records field: a cell per column. */
+export type FlowRecordRow = Readonly<Record<string, string | number | boolean | null>>;
+
+/** A record a pick step chose: its id and the label the tray and the review page show. */
+export interface FlowPickedRecord { readonly id: string; readonly label: string }
 
 /** The field types: the shared grid editors, the types flows add, and custom editors. */
 export type FlowFieldType = "text" | "number" | "date" | "datetime" | "time" | "select" | "toggle" | "lookup" | "choice" | "multiChoice"
-  | "textarea" | "list" | "secret" | "duration" | "custom";
+  | "textarea" | "list" | "secret" | "duration" | "records" | "custom";
 
 /** A condition operator, from the filter builder's grammar. */
 export type FlowOperator = "eq" | "ne" | "gt" | "ge" | "lt" | "le" | "contains" | "notContains" | "startsWith" | "endsWith" | "matches" | "notMatches"
@@ -77,17 +83,73 @@ export interface FlowField {
   units?: readonly ("seconds" | "minutes" | "hours" | "days")[];
   /** Custom fields: the registered editor's name. */
   editor?: string;
+  /** Select, choice, multiple-choice and lookup fields: "host" takes the options from hooks.options (or an endpoint). */
+  source?: "document" | "host";
+  /** The fields (at most 16, never secrets) whose change reloads host options, or empties this answer. */
+  dependsOn?: readonly string[];
+  /** Records fields: the columns of each row (1 to 16). */
+  columns?: readonly FlowRecordColumn[];
+}
+
+/** A column of a records field. */
+export interface FlowRecordColumn {
+  id: string;
+  title: string;
+  type?: "text" | "number" | "date" | "time" | "select" | "toggle";
+  required?: boolean;
+  options?: readonly FlowOption[];
+  validation?: { min?: number; max?: number; minLength?: number; maxLength?: number; pattern?: string; message?: string };
+  width?: number;
+}
+
+/** A server check of some answers, such as "Send a test message", run through hooks.check (or an endpoint). */
+export interface FlowCheck {
+  id: string;
+  label: string;
+  description?: string;
+  /** The fields it tests (1 to 64); a change marks its result stale. Secrets among them reach the hook through secret(id). */
+  fields: readonly string[];
+  /** "pass" blocks Next until it passes on the current answers; "run" until it ran on them without failing. */
+  required?: "pass" | "run";
+}
+
+/** A pick step's picker: a grid or tree view whose selection is the step's answer. */
+export interface FlowPick {
+  field: {
+    id: string; label?: string; help?: string; required?: boolean; when?: FlowCondition; parameter?: string; path?: string; sensitive?: boolean;
+    validation?: Pick<FlowValidation, "minItems" | "maxItems" | "message">; default?: readonly FlowPickedRecord[];
+  };
+  /** The grid or tree view document (canopyx/2). */
+  view: Readonly<Record<string, unknown>>;
+  /** The view column whose value labels a picked record. */
+  label: string;
+  /** Whether the tray of picked records shows (default true). */
+  tray?: boolean;
+  height?: number;
 }
 
-/** A section of a step: a heading over some of its fields. */
-export interface FlowSection { id: string; label: string; description?: string; fields: readonly FlowField[]; when?: FlowCondition }
+/** A preset the reader can start from. */
+export interface FlowPreset { id: string; label: string; description?: string; values: Readonly<Record<string, FlowValue>> }
 
-/** A step: a form, a page of text, or the review page (which comes last). */
+/** A section of a step: a heading over some of its fields, or over fields the host supplies. */
+export interface FlowSection {
+  id: string;
+  label: string;
+  description?: string;
+  /** The section's own fields; none when its fields come from the host. */
+  fields?: readonly FlowField[];
+  when?: FlowCondition;
+  /** "host": hooks.fields (or an endpoint) supplies the fields as the step opens, and again when a field in dependsOn changes. */
+  source?: "host";
+  dependsOn?: readonly string[];
+}
+
+/** A step: a form, a page of text, a pick step, or the review page (which comes last). */
 export interface FlowStep {
   id: string;
   title?: string;
   description?: string;
-  type?: "form" | "info" | "review";
+  type?: "form" | "info" | "pick" | "review";
   fields?: readonly FlowField[];
   sections?: readonly FlowSection[];
   when?: FlowCondition;
@@ -96,6 +158,19 @@ export interface FlowStep {
   declaration?: string;
   /** Review steps in edit mode: whether only changed answers show first (default true). */
   changesOnly?: boolean;
+  /** Form steps: server checks (at most 8). */
+  checks?: readonly FlowCheck[];
+  /** Task lists: the heading the task sits under. */
+  group?: string;
+  /** Pick steps: the picker. */
+  pick?: FlowPick;
+  /** Review steps: a text the reader types before submitting, or a field whose answer they type. */
+  confirm?: { label: string; text?: string; field?: string };
+  /** Review steps: a box the reader ticks before submitting, while the condition holds. */
+  acknowledge?: { label: string; when?: FlowCondition };
+  /** Review steps: true says the review page shows the host's preview (hooks.preview), so the page loads the preview part with
+   *  the flow; without it, a preview hook loads the part on its own. */
+  preview?: boolean;
 }
 
 /** A flow document, the contract C# writes with CanopyFlow and any host can map. */
@@ -105,8 +180,9 @@ export interface FlowDocument {
   id: string;
   title: string;
   description?: string;
-  mode?: "linear" | "free";
-  layout?: { orientation?: "auto" | "horizontal" | "vertical" };
+  mode?: "linear" | "free" | "tasks";
+  /** Container "dialog" or "drawer" opens the flow from a launch button. */
+  layout?: { orientation?: "auto" | "horizontal" | "vertical"; container?: "inline" | "dialog" | "drawer"; launch?: string };
   density?: "compact" | "normal" | "comfortable";
   timeZone?: "utc" | "local";
   steps: readonly FlowStep[];
@@ -117,6 +193,15 @@ export interface FlowDocument {
   baseline?: string;
   submit?: { label?: string };
   labels?: Readonly<Record<string, string>>;
+  /** The equivalent command the review page shows; variants come from hooks.commands. */
+  command?: { name: string; style?: "powershell" | "posix" | "windows"; variants?: readonly { id: string; label: string }[] };
+  presets?: readonly FlowPreset[];
+  /** Where the draft lives: nowhere (the default), the session, local storage, or hooks.draftStore. */
+  draft?: "none" | "session" | "local" | "host";
+  /** Whether the page's address names the open step (#flow-id/step-id). */
+  deepLinks?: boolean;
+  /** Routes on the page's own origin that answer the hooks the host left unset (CanopyX.AspNetCore's MapCanopyFlow). */
+  endpoint?: { url: string; routes: readonly ("options" | "fields" | "check" | "validate" | "preview" | "status" | "draft" | "submit")[] };
 }
 
 /** The proposal flowSubmit carries: visible answers, secret states, the changes and a JSON patch. Never a secret value. */
@@ -130,8 +215,50 @@ export interface FlowSubmission {
   secrets: Record<string, { state: "set" | "keep" }>;
   changes: { field: string; path?: string; from: FlowValue; to: FlowValue }[];
   patch: ({ op: "add" | "replace"; path: string; value: FlowValue } | { op: "remove"; path: string })[];
+  /** The checks that ran on these answers, as the browser saw them: a claim the server runs again before relying on it. */
+  checks?: Record<string, { status: FlowCheckStatus; at: string }>;
+  /** The equivalent command of these answers; typed secrets read <secret>. */
+  command?: string;
+  /** The preset the answers started from. */
+  preset?: string;
+}
+
+/** A check's outcome. */
+export type FlowCheckStatus = "pass" | "warning" | "fail";
+
+/** What a check answers. */
+export interface FlowCheckResult {
+  status: FlowCheckStatus;
+  message?: string;
+  details?: { label: string; value: string | number | boolean }[];
+  fieldErrors?: Record<string, string>;
 }
 
+/** A task's state on a task-list flow, as the host sees it. */
+export interface FlowStepState { state: "complete" | "needsAction" | "blocked" | "notStarted"; summary?: string; blockers?: string[] }
+
+/** A row of the review page's preview. */
+export interface FlowPreviewRow { label: string; value: string | number | boolean; tone?: "info" | "success" | "warning" | "danger" }
+
+/** The review page's preview: rows of what submitting does, or a title, rows and notes. Text only. */
+export type FlowPreview = readonly FlowPreviewRow[] | { title?: string; rows?: readonly FlowPreviewRow[]; notes?: readonly string[] };
+
+/** A draft: the answers (never secrets or sensitive fields), the open step, the completed steps, the preset and the baseline. */
+export interface FlowDraft {
+  kind: "flowDraft";
+  version: 1;
+  flow: string;
+  step: string;
+  completed: string[];
+  values: Record<string, FlowValue>;
+  saved: string;
+  baseline?: string;
+  preset?: string;
+}
+
+/** What an asynchronous hook receives: a signal that a newer request, Cancel, the timeout or destroy aborts. */
+export interface FlowHookContext { signal: AbortSignal }
+
 /** The submit event's detail: the proposal, how to answer it, and each secret once. */
 export interface FlowSubmitDetail extends Readonly<FlowSubmission> {
   respondWith(answer: FlowAnswer | Promise<FlowAnswer>): void;
@@ -159,6 +286,24 @@ export interface FlowHooks {
   validateStep?(stepId: string, values: Record<string, FlowValue>): FlowRuleResult | Promise<FlowRuleResult>;
   validateFlow?(values: Record<string, FlowValue>): FlowRuleResult | Promise<FlowRuleResult>;
   submit?(detail: FlowSubmitDetail): FlowAnswer | Promise<FlowAnswer>;
+  /** The options of a field whose source is "host". */
+  options?(fieldId: string, values: Record<string, FlowValue>, context: FlowHookContext): readonly FlowOption[] | Promise<readonly FlowOption[]>;
+  /** The fields of a host section: at most 64, of the plain types, without path, source or dependsOn. */
+  fields?(sectionId: string, values: Record<string, FlowValue>, context: FlowHookContext): readonly FlowField[] | Promise<readonly FlowField[]>;
+  /** Runs a check; secret(id) reads, once, a secret among the fields it tests. */
+  check?(checkId: string, values: Record<string, FlowValue>, context: FlowHookContext & { secret(fieldId: string): string | null }): FlowCheckResult | Promise<FlowCheckResult>;
+  /** The review page's preview of what submitting does. */
+  preview?(values: Record<string, FlowValue>, context: FlowHookContext): FlowPreview | Promise<FlowPreview>;
+  /** A task list's step states, by step id. */
+  status?(values: Record<string, FlowValue>, context: FlowHookContext): Record<string, FlowStepState> | Promise<Record<string, FlowStepState>>;
+  /** The command's variants, by variant id: each writes the command line of the answers. */
+  commands?: Record<string, (values: Record<string, FlowValue>) => string | Promise<string>>;
+  /** The store of draft "host". */
+  draftStore?: { load(flowId: string): FlowDraft | null | Promise<FlowDraft | null>; save(flowId: string, draft: FlowDraft): void | Promise<void>; clear(flowId: string): void | Promise<void> };
+  /** Presets the host keeps; save adds "Save as preset". */
+  presetStore?: { list(flowId: string): readonly FlowPreset[] | Promise<readonly FlowPreset[]>; save?(flowId: string, preset: FlowPreset): void | Promise<void> };
+  /** Grid or tree options of a pick step's view, by step id, such as a remote data source. */
+  pickers?: Record<string, Readonly<Record<string, unknown>>>;
 }
 
 /** Options of createFlow and CanopyX.configure for a flow fragment. */
@@ -176,6 +321,17 @@ export interface FlowOptions {
   onSubmit?(detail: FlowSubmitDetail): FlowAnswer | Promise<FlowAnswer> | void;
   onSubmitted?(answer: FlowAnswer): void;
   onReload?(detail: { baseline: string | null }): void;
+  onCheck?(detail: { check: string; result: { status: FlowCheckStatus; message: string | null; details: { label: string; value: string }[]; at: string } }): void;
+  /** A dialog or drawer flow closes with answers; false (or cancelling flowLeaving) keeps it open. */
+  onLeaving?(detail: { reason: "close" }): boolean | void;
+  /** Deep links: a step's fragment, in place of "flow-id/step-id". */
+  formatLink?(stepId: string): string | null;
+  /** Deep links: the step a fragment names, or null. */
+  parseLink?(fragment: string): string | null;
+  /** How long an asynchronous hook may take, in milliseconds: 100 to 600000, default 30000. */
+  timeout?: number;
+  /** Headers an endpoint's requests carry, such as an antiforgery token. */
+  headers?: Record<string, string>;
 }
 
 /** A validation result: the errors and warnings of a step or the whole flow. */
@@ -212,6 +368,21 @@ export interface FlowApi {
   submit(): Promise<FlowAnswer | null>;
   setProgress(progress: { done?: number; total?: number; message?: string }): boolean;
   complete(answer: FlowAnswer): boolean;
+  /** Runs a check now; resolves with its result as the flow keeps it (field messages show in place), or null when it was cancelled.
+   *  Rejects for a check the flow does not have. */
+  runCheck(checkId: string): Promise<{ status: FlowCheckStatus; message: string | null; details: { label: string; value: string }[]; at: string } | null>;
+  /** Loads a host-option field's options again. Rejects for any other field. */
+  refreshOptions(fieldId: string): Promise<void>;
+  /** Sets a task's state as the host sees it; null returns it to what the answers say. Throws for a flow that is no task list. */
+  setStepState(stepId: string, state: FlowStepState | null): void;
+  /** Saves the draft now; resolves with whether it was saved (false for a flow without a draft store). */
+  saveDraft(): Promise<boolean>;
+  /** Starts from a preset, or from the plain start with null. Rejects for a preset the flow does not have. */
+  setPreset(presetId: string | null): Promise<void>;
+  /** Dialog and drawer flows: opens the container; true once it is open, false for an inline flow. */
+  open(): boolean;
+  /** Dialog and drawer flows: closes the container, asking first when answers would be lost; false when it stays open. */
+  close(): boolean;
   /** Releases the flow and its host's mount state, even before ready or after mount failure. Repeated calls do nothing. */
   destroy(): void;
 }

package/JavaScript/grid.d.ts

@@ -887,6 +887,8 @@ export interface DataGrid<Q extends AcceptedGridQuery = GridQuery, Row extends G
   getSelection(): string[];
   setSelection(ids: string[]): void;
   clearSelection(): void;
+  /** The loaded records among ids, as copies of { id, cells }; a record that is not loaded now is left out. Never fetches. */
+  getLoadedRows(ids: readonly string[]): { id: string; cells: Record<string, Cell> }[];
   prepareExport(options: GridExportOptions): GridExport<Q>;
   toCsv(options: GridExportOptions): Promise<string>;
   copy(options: GridExportOptions): Promise<string>;

package/JavaScript/locales/de.mjs

@@ -588,6 +588,80 @@ const labels = Object.freeze({
   flowCopied: "Kopiert",
   flowSavedIt: "Ich habe es gespeichert",
   flowShownOnce: "Wird nur einmal angezeigt. Jetzt kopieren.",
+  flowTimedOut: "Der Host hat nicht rechtzeitig geantwortet.",
+  flowNoHostHook: "Der Host beantwortet das nicht.",
+  flowOptionsLoading: "Optionen werden geladen…",
+  flowOptionsFailed: "Die Optionen konnten nicht geladen werden: {message}",
+  flowRetry: "Erneut versuchen",
+  flowRunAgain: "Erneut ausführen",
+  flowRunCheckAgain: "„{check}“ erneut ausführen",
+  flowFieldsLoading: "Felder werden geladen…",
+  flowFieldsFailed: "Die Felder konnten nicht geladen werden: {message}",
+  flowChangedMark: "Geändert",
+  flowRecordActions: "Aktionen",
+  flowRecordCell: "{column}, Zeile {row}",
+  flowRecordRemove: "Zeile {row} entfernen",
+  flowRecordAdd: "Zeile hinzufügen",
+  flowRecordsEmpty: "Noch keine Zeilen.",
+  flowRecordProblem: "Zeile {row}: {message}",
+  flowRecordsCount: "[one]{count} Zeile[other]{count} Zeilen",
+  flowPickMore: "und {count} weitere",
+  flowPickCount: "[one]{count} ausgewählt[other]{count} ausgewählt",
+  flowPickChosen: "Ausgewählt",
+  flowPickNone: "Noch nichts ausgewählt.",
+  flowChecks: "Prüfungen",
+  flowCancel: "Abbrechen",
+  flowCheckAcknowledge: "Trotz der Warnung fortfahren",
+  flowCheckRunning: "Wird geprüft…",
+  flowCheckNotRun: "Nicht ausgeführt",
+  flowCheckStale: "Die Antworten haben sich seit der Prüfung geändert",
+  flowCheckPassed: "Bestanden um {time}",
+  flowCheckWarning: "Warnung um {time}",
+  flowCheckFailed: "Fehlgeschlagen um {time}",
+  flowCheckInvalid: "Die Prüfung lieferte keine verwertbare Antwort.",
+  flowCheckNeeded: "Führen Sie „{check}“ mit diesen Antworten aus.",
+  flowCheckNotPassed: "„{check}“ wurde nicht bestanden.",
+  flowCheckConfirmWarning: "Bestätigen Sie die Warnung von „{check}“.",
+  flowTasks: "Aufgaben",
+  flowTasksProgress: "{done} von {count} Aufgaben erledigt",
+  flowTaskNeedsAction: "Handlungsbedarf",
+  flowTaskBlocked: "Kann noch nicht beginnen",
+  flowTasksReview: "Prüfen und absenden",
+  flowTasksIncomplete: "Erledigen Sie zuerst die erforderlichen Aufgaben.",
+  flowBackToTasks: "Zurück zu den Aufgaben",
+  flowSaveAndReturn: "Speichern und zurück",
+  flowSaveDraft: "Entwurf speichern",
+  flowClose: "Schließen",
+  flowDiscardQuestion: "Ihre Antworten verwerfen?",
+  flowDiscard: "Verwerfen",
+  flowKeepEditing: "Weiter bearbeiten",
+  flowDraftSaved: "Entwurf gespeichert",
+  flowDraftFailed: "Der Entwurf wurde nicht gespeichert.",
+  flowDraftFound: "Gespeicherter Entwurf",
+  flowDraftFrom: "Sie haben einen Entwurf vom {time}.",
+  flowDraftStale: "Die Einstellungen haben sich nach dem Speichern dieses Entwurfs geändert.",
+  flowDraftResume: "Dort weitermachen, wo Sie aufgehört haben",
+  flowDraftRestart: "Neu beginnen",
+  flowStartFrom: "Ausgangspunkt",
+  flowPresetSave: "Als Vorlage speichern",
+  flowPresetNone: "Standardwerte",
+  flowPresetsSaved: "Gespeicherte Vorlagen",
+  flowPresetApplied: "Ausgehend von {preset}",
+  flowPresetName: "Name der Vorlage",
+  flowPresetFailed: "Die Vorlage wurde nicht gespeichert.",
+  flowPresetSaved: "Vorlage {preset} gespeichert",
+  flowPresetChanges: "[one]Basierend auf {preset}, {count} Änderung[other]Basierend auf {preset}, {count} Änderungen",
+  flowCommandTab: "Befehl",
+  flowPatchTab: "JSON-Patch",
+  flowCommandTitle: "Entsprechender Befehl",
+  flowPreview: "Vorschau",
+  flowPreviewLoading: "Vorschau wird geladen…",
+  flowPreviewFailed: "Die Vorschau konnte nicht geladen werden: {message}",
+  flowPreviewNone: "Keine Vorschau.",
+  flowConfirmMismatch: "Geben Sie genau {text} ein, um fortzufahren.",
+  flowAcknowledgeNeeded: "Bestätigen Sie dies vor dem Absenden.",
+  flowPresetCurrent: "Aktuelle Einstellungen",
+  flowPickOneByOne: "Wählen Sie die Datensätze einzeln oder seitenweise aus.",
   matrixRows: "Zeilen",
   matrixColumns: "Spalten",
   matrixSearch: "Zeilen und Spalten suchen",

package/JavaScript/locales/es.mjs

@@ -588,6 +588,80 @@ const labels = Object.freeze({
   flowCopied: "Copiado",
   flowSavedIt: "Lo he guardado",
   flowShownOnce: "Se muestra solo una vez. Cópielo ahora.",
+  flowTimedOut: "El host no respondió a tiempo.",
+  flowNoHostHook: "Ningún host responde a esto.",
+  flowOptionsLoading: "Cargando opciones…",
+  flowOptionsFailed: "No se pudieron cargar las opciones: {message}",
+  flowRetry: "Reintentar",
+  flowRunAgain: "Volver a ejecutar",
+  flowRunCheckAgain: "Volver a ejecutar «{check}»",
+  flowFieldsLoading: "Cargando campos…",
+  flowFieldsFailed: "No se pudieron cargar los campos: {message}",
+  flowChangedMark: "Modificado",
+  flowRecordActions: "Acciones",
+  flowRecordCell: "{column}, fila {row}",
+  flowRecordRemove: "Quitar la fila {row}",
+  flowRecordAdd: "Añadir fila",
+  flowRecordsEmpty: "Todavía no hay filas.",
+  flowRecordProblem: "Fila {row}: {message}",
+  flowRecordsCount: "[one]{count} fila[other]{count} filas",
+  flowPickMore: "y {count} más",
+  flowPickCount: "[one]{count} elegido[other]{count} elegidos",
+  flowPickChosen: "Elegidos",
+  flowPickNone: "Todavía no se ha elegido nada.",
+  flowChecks: "Comprobaciones",
+  flowCancel: "Cancelar",
+  flowCheckAcknowledge: "Continuar pese a la advertencia",
+  flowCheckRunning: "Comprobando…",
+  flowCheckNotRun: "Sin ejecutar",
+  flowCheckStale: "Las respuestas cambiaron desde la comprobación",
+  flowCheckPassed: "Superada a las {time}",
+  flowCheckWarning: "Advertencia a las {time}",
+  flowCheckFailed: "Falló a las {time}",
+  flowCheckInvalid: "La comprobación no dio una respuesta válida.",
+  flowCheckNeeded: "Ejecute «{check}» con estas respuestas.",
+  flowCheckNotPassed: "«{check}» no se superó.",
+  flowCheckConfirmWarning: "Confirme la advertencia de «{check}».",
+  flowTasks: "Tareas",
+  flowTasksProgress: "{done} de {count} tareas completadas",
+  flowTaskNeedsAction: "Requiere acción",
+  flowTaskBlocked: "Aún no se puede empezar",
+  flowTasksReview: "Revisar y enviar",
+  flowTasksIncomplete: "Complete primero las tareas obligatorias.",
+  flowBackToTasks: "Volver a las tareas",
+  flowSaveAndReturn: "Guardar y volver",
+  flowSaveDraft: "Guardar borrador",
+  flowClose: "Cerrar",
+  flowDiscardQuestion: "¿Descartar sus respuestas?",
+  flowDiscard: "Descartar",
+  flowKeepEditing: "Seguir editando",
+  flowDraftSaved: "Borrador guardado",
+  flowDraftFailed: "No se guardó el borrador.",
+  flowDraftFound: "Borrador guardado",
+  flowDraftFrom: "Tiene un borrador guardado el {time}.",
+  flowDraftStale: "La configuración cambió después de guardar este borrador.",
+  flowDraftResume: "Continuar donde lo dejó",
+  flowDraftRestart: "Empezar de nuevo",
+  flowStartFrom: "Empezar desde",
+  flowPresetSave: "Guardar como plantilla",
+  flowPresetNone: "Valores predeterminados",
+  flowPresetsSaved: "Plantillas guardadas",
+  flowPresetApplied: "Se empezó desde {preset}",
+  flowPresetName: "Nombre de la plantilla",
+  flowPresetFailed: "No se guardó la plantilla.",
+  flowPresetSaved: "Plantilla {preset} guardada",
+  flowPresetChanges: "[one]Basado en {preset}, {count} cambio[other]Basado en {preset}, {count} cambios",
+  flowCommandTab: "Comando",
+  flowPatchTab: "JSON patch",
+  flowCommandTitle: "Comando equivalente",
+  flowPreview: "Vista previa",
+  flowPreviewLoading: "Cargando la vista previa…",
+  flowPreviewFailed: "No se pudo cargar la vista previa: {message}",
+  flowPreviewNone: "Nada que previsualizar.",
+  flowConfirmMismatch: "Escriba exactamente {text} para continuar.",
+  flowAcknowledgeNeeded: "Confírmelo antes de enviar.",
+  flowPresetCurrent: "Configuración actual",
+  flowPickOneByOne: "Elija los registros uno a uno o por páginas.",
   matrixRows: "Filas",
   matrixColumns: "Columnas",
   matrixSearch: "Buscar filas y columnas",

package/JavaScript/locales/fr.mjs

@@ -588,6 +588,80 @@ const labels = Object.freeze({
   flowCopied: "Copié",
   flowSavedIt: "Je l'ai enregistré",
   flowShownOnce: "Affiché une seule fois. Copiez-le maintenant.",
+  flowTimedOut: "L’hôte n’a pas répondu à temps.",
+  flowNoHostHook: "Aucun hôte ne répond à cela.",
+  flowOptionsLoading: "Chargement des options…",
+  flowOptionsFailed: "Impossible de charger les options : {message}",
+  flowRetry: "Réessayer",
+  flowRunAgain: "Relancer",
+  flowRunCheckAgain: "Relancer « {check} »",
+  flowFieldsLoading: "Chargement des champs…",
+  flowFieldsFailed: "Impossible de charger les champs : {message}",
+  flowChangedMark: "Modifié",
+  flowRecordActions: "Actions",
+  flowRecordCell: "{column}, ligne {row}",
+  flowRecordRemove: "Supprimer la ligne {row}",
+  flowRecordAdd: "Ajouter une ligne",
+  flowRecordsEmpty: "Aucune ligne pour l’instant.",
+  flowRecordProblem: "Ligne {row} : {message}",
+  flowRecordsCount: "[one]{count} ligne[other]{count} lignes",
+  flowPickMore: "et {count} de plus",
+  flowPickCount: "[one]{count} choisi[other]{count} choisis",
+  flowPickChosen: "Choisis",
+  flowPickNone: "Rien n’est encore choisi.",
+  flowChecks: "Vérifications",
+  flowCancel: "Annuler",
+  flowCheckAcknowledge: "Continuer malgré l’avertissement",
+  flowCheckRunning: "Vérification…",
+  flowCheckNotRun: "Non exécutée",
+  flowCheckStale: "Les réponses ont changé depuis la vérification",
+  flowCheckPassed: "Réussie à {time}",
+  flowCheckWarning: "Avertissement à {time}",
+  flowCheckFailed: "Échec à {time}",
+  flowCheckInvalid: "La vérification n’a pas donné de réponse exploitable.",
+  flowCheckNeeded: "Lancez « {check} » avec ces réponses.",
+  flowCheckNotPassed: "« {check} » n’a pas réussi.",
+  flowCheckConfirmWarning: "Confirmez l’avertissement de « {check} ».",
+  flowTasks: "Tâches",
+  flowTasksProgress: "{done} tâches sur {count} terminées",
+  flowTaskNeedsAction: "Action requise",
+  flowTaskBlocked: "Ne peut pas encore commencer",
+  flowTasksReview: "Vérifier et envoyer",
+  flowTasksIncomplete: "Terminez d’abord les tâches requises.",
+  flowBackToTasks: "Retour aux tâches",
+  flowSaveAndReturn: "Enregistrer et revenir",
+  flowSaveDraft: "Enregistrer le brouillon",
+  flowClose: "Fermer",
+  flowDiscardQuestion: "Abandonner vos réponses ?",
+  flowDiscard: "Abandonner",
+  flowKeepEditing: "Continuer la saisie",
+  flowDraftSaved: "Brouillon enregistré",
+  flowDraftFailed: "Le brouillon n’a pas été enregistré.",
+  flowDraftFound: "Brouillon enregistré",
+  flowDraftFrom: "Vous avez un brouillon enregistré le {time}.",
+  flowDraftStale: "Les paramètres ont changé depuis l’enregistrement de ce brouillon.",
+  flowDraftResume: "Reprendre là où vous en étiez",
+  flowDraftRestart: "Recommencer",
+  flowStartFrom: "Partir de",
+  flowPresetSave: "Enregistrer comme modèle",
+  flowPresetNone: "Valeurs par défaut",
+  flowPresetsSaved: "Modèles enregistrés",
+  flowPresetApplied: "Parti de {preset}",
+  flowPresetName: "Nom du modèle",
+  flowPresetFailed: "Le modèle n’a pas été enregistré.",
+  flowPresetSaved: "Modèle {preset} enregistré",
+  flowPresetChanges: "[one]D’après {preset}, {count} modification[other]D’après {preset}, {count} modifications",
+  flowCommandTab: "Commande",
+  flowPatchTab: "JSON patch",
+  flowCommandTitle: "Commande équivalente",
+  flowPreview: "Aperçu",
+  flowPreviewLoading: "Chargement de l’aperçu…",
+  flowPreviewFailed: "Impossible de charger l’aperçu : {message}",
+  flowPreviewNone: "Rien à prévisualiser.",
+  flowConfirmMismatch: "Saisissez exactement {text} pour continuer.",
+  flowAcknowledgeNeeded: "Confirmez ceci avant d’envoyer.",
+  flowPresetCurrent: "Paramètres actuels",
+  flowPickOneByOne: "Choisissez les enregistrements un par un ou page par page.",
   matrixRows: "Lignes",
   matrixColumns: "Colonnes",
   matrixSearch: "Rechercher des lignes et des colonnes",

package/JavaScript/locales/it.mjs

@@ -588,6 +588,80 @@ const labels = Object.freeze({
   flowCopied: "Copiato",
   flowSavedIt: "L'ho salvato",
   flowShownOnce: "Mostrato una sola volta. Copialo ora.",
+  flowTimedOut: "L’host non ha risposto in tempo.",
+  flowNoHostHook: "Nessun host risponde a questo.",
+  flowOptionsLoading: "Caricamento delle opzioni…",
+  flowOptionsFailed: "Impossibile caricare le opzioni: {message}",
+  flowRetry: "Riprova",
+  flowRunAgain: "Esegui di nuovo",
+  flowRunCheckAgain: "Esegui di nuovo «{check}»",
+  flowFieldsLoading: "Caricamento dei campi…",
+  flowFieldsFailed: "Impossibile caricare i campi: {message}",
+  flowChangedMark: "Modificato",
+  flowRecordActions: "Azioni",
+  flowRecordCell: "{column}, riga {row}",
+  flowRecordRemove: "Rimuovi la riga {row}",
+  flowRecordAdd: "Aggiungi riga",
+  flowRecordsEmpty: "Ancora nessuna riga.",
+  flowRecordProblem: "Riga {row}: {message}",
+  flowRecordsCount: "[one]{count} riga[other]{count} righe",
+  flowPickMore: "e altri {count}",
+  flowPickCount: "[one]{count} scelto[other]{count} scelti",
+  flowPickChosen: "Scelti",
+  flowPickNone: "Ancora nulla di scelto.",
+  flowChecks: "Verifiche",
+  flowCancel: "Annulla",
+  flowCheckAcknowledge: "Continua nonostante l’avviso",
+  flowCheckRunning: "Verifica in corso…",
+  flowCheckNotRun: "Non eseguita",
+  flowCheckStale: "Le risposte sono cambiate dopo la verifica",
+  flowCheckPassed: "Superata alle {time}",
+  flowCheckWarning: "Avviso alle {time}",
+  flowCheckFailed: "Non riuscita alle {time}",
+  flowCheckInvalid: "La verifica non ha dato una risposta utilizzabile.",
+  flowCheckNeeded: "Esegui «{check}» con queste risposte.",
+  flowCheckNotPassed: "«{check}» non è stata superata.",
+  flowCheckConfirmWarning: "Conferma l’avviso di «{check}».",
+  flowTasks: "Attività",
+  flowTasksProgress: "{done} di {count} attività completate",
+  flowTaskNeedsAction: "Richiede un intervento",
+  flowTaskBlocked: "Non può ancora iniziare",
+  flowTasksReview: "Rivedi e invia",
+  flowTasksIncomplete: "Completa prima le attività obbligatorie.",
+  flowBackToTasks: "Torna alle attività",
+  flowSaveAndReturn: "Salva e torna indietro",
+  flowSaveDraft: "Salva bozza",
+  flowClose: "Chiudi",
+  flowDiscardQuestion: "Scartare le risposte?",
+  flowDiscard: "Scarta",
+  flowKeepEditing: "Continua a modificare",
+  flowDraftSaved: "Bozza salvata",
+  flowDraftFailed: "La bozza non è stata salvata.",
+  flowDraftFound: "Bozza salvata",
+  flowDraftFrom: "Hai una bozza salvata il {time}.",
+  flowDraftStale: "Le impostazioni sono cambiate dopo il salvataggio di questa bozza.",
+  flowDraftResume: "Riprendi da dove avevi lasciato",
+  flowDraftRestart: "Ricomincia",
+  flowStartFrom: "Parti da",
+  flowPresetSave: "Salva come modello",
+  flowPresetNone: "Valori predefiniti",
+  flowPresetsSaved: "Modelli salvati",
+  flowPresetApplied: "Avviato da {preset}",
+  flowPresetName: "Nome del modello",
+  flowPresetFailed: "Il modello non è stato salvato.",
+  flowPresetSaved: "Modello {preset} salvato",
+  flowPresetChanges: "[one]In base a {preset}, {count} modifica[other]In base a {preset}, {count} modifiche",
+  flowCommandTab: "Comando",
+  flowPatchTab: "JSON patch",
+  flowCommandTitle: "Comando equivalente",
+  flowPreview: "Anteprima",
+  flowPreviewLoading: "Caricamento dell’anteprima…",
+  flowPreviewFailed: "Impossibile caricare l’anteprima: {message}",
+  flowPreviewNone: "Niente da visualizzare.",
+  flowConfirmMismatch: "Digita esattamente {text} per continuare.",
+  flowAcknowledgeNeeded: "Conferma prima di inviare.",
+  flowPresetCurrent: "Impostazioni attuali",
+  flowPickOneByOne: "Scegli i record uno alla volta o una pagina alla volta.",
   matrixRows: "Righe",
   matrixColumns: "Colonne",
   matrixSearch: "Cerca righe e colonne",