@adminiumjs/i18n 0.2.5 → 0.2.6

package/dist/resources/en-us/automations.d.ts

@@ -0,0 +1,417 @@
+/**
+ * GENERATED MIRROR of ../../../locales/en-US/automations.json — do not edit by hand.
+ * The JSON file is the canonical hand-authored bundle (10-i18n-theming.md §3.1);
+ * this TS mirror exists so the runtime can bundle a namespace (en-US's eager
+ * ones) or chunk-split it (every other locale, and en-US's deferred `studio`)
+ * without JSON import attributes (browser + NodeNext safe).
+ * Parity is enforced by src/resources/parity.test.ts. Regenerate with
+ * scripts/gen-resources.mjs.
+ */
+declare const _default: {
+    readonly rules: {
+        readonly title: "Automation rules";
+        readonly subtitle: "Trigger workflows automatically when things happen.";
+        readonly new: "New rule";
+        readonly empty: {
+            readonly title: "No rules yet";
+            readonly body: "Create a rule to run steps automatically when something happens.";
+        };
+        readonly none: "Select a rule to see its flow";
+    };
+    readonly kpi: {
+        readonly activeRules: "Active rules";
+        readonly runsToday: "Runs today";
+        readonly successRate: "Success rate";
+        readonly timeSaved: "Time saved (mo)";
+    };
+    readonly filter: {
+        readonly all: "All";
+        readonly active: "Active";
+        readonly paused: "Paused";
+    };
+    readonly card: {
+        readonly runs: "runs";
+        readonly success: "success";
+        readonly never: "Never run";
+        readonly toggle: "Toggle";
+    };
+    readonly status: {
+        readonly active: "Active";
+        readonly paused: "Paused";
+    };
+    readonly flow: {
+        readonly steps: "{count, plural, one {# step} other {# steps}}";
+        readonly saves: "saves {time} / run";
+        readonly runs30d: "runs 30d";
+        readonly success: "success";
+        readonly test: "Test";
+        readonly running: "Running";
+        readonly noSample: "No record to test with — add one first";
+        readonly menu: "Rule actions";
+    };
+    readonly menu: {
+        readonly rename: "Rename";
+        readonly duplicate: "Duplicate";
+        readonly delete: "Delete";
+    };
+    readonly delete: {
+        readonly title: "Delete {name}?";
+        readonly body: "Its run history goes with it. This cannot be undone.";
+        readonly confirm: "Delete";
+        readonly cancel: "Cancel";
+    };
+    readonly save: {
+        readonly unsaved: "Unsaved changes";
+        readonly saving: "Saving…";
+        readonly saved: "All changes saved";
+        readonly action: "Save";
+    };
+    readonly guard: {
+        readonly title: "Leave without saving?";
+        readonly body: "Your changes to this rule will be lost.";
+        readonly stay: "Keep editing";
+        readonly leave: "Leave";
+    };
+    readonly toast: {
+        readonly saved: "Rule saved";
+        readonly enabled: "{name} is on";
+        readonly paused: "{name} is paused";
+        readonly incomplete: "Finish “{step}” before switching this rule on";
+        readonly duplicated: "{name} duplicated";
+        readonly deleted: "{name} deleted";
+        readonly failed: "That did not save — {reason}";
+    };
+    readonly canvas: {
+        readonly insert: "Insert step here";
+        readonly addStep: "Add step";
+        readonly remove: "Remove step";
+    };
+    readonly kind: {
+        readonly trigger: "TRIGGER";
+        readonly condition: "FILTER";
+        readonly branch: "IF / ELSE";
+        readonly wait: "DELAY";
+        readonly action: "ACTION";
+    };
+    readonly branch: {
+        readonly ifMatches: "If matches";
+        readonly otherwise: "Otherwise";
+    };
+    readonly picker: {
+        readonly title: "Add a step";
+        readonly before: "Before · {title}";
+        readonly end: "At the end of the flow";
+        readonly inBranch: "Inside branch · {label}";
+        readonly actions: "Actions";
+        readonly logic: "Logic";
+        readonly close: "Close";
+    };
+    readonly pick: {
+        readonly email: "Send email";
+        readonly emailDesc: "From a saved template";
+        readonly notification: "Send notification";
+        readonly notificationDesc: "Tell people in this workspace";
+        readonly create: "Create record";
+        readonly createDesc: "Add a row to a table";
+        readonly update: "Update field";
+        readonly updateDesc: "Write back to a record";
+        readonly webhook: "Call webhook";
+        readonly webhookDesc: "Send data anywhere";
+        readonly slack: "Slack message";
+        readonly slackDesc: "Post to a channel";
+        readonly branch: "If / else branch";
+        readonly branchDesc: "Split into two paths";
+        readonly filter: "Only continue if";
+        readonly filterDesc: "Stop when unmatched";
+        readonly wait: "Wait / delay";
+        readonly waitDesc: "Hold before next step";
+        readonly stop: "Stop workflow";
+        readonly stopDesc: "Halt this run here";
+    };
+    readonly node: {
+        readonly email: {
+            readonly sub: "Template · pick one";
+            readonly summary: "Template · {template} → {to}";
+        };
+        readonly notification: {
+            readonly sub: "Choose who to tell";
+            readonly summary: "To · {who}";
+        };
+        readonly create: {
+            readonly sub: "Table · pick one";
+            readonly summary: "{table} · {count} values";
+        };
+        readonly update: {
+            readonly sub: "Set a value";
+            readonly summary: "{pairs}";
+        };
+        readonly webhook: {
+            readonly sub: "POST · JSON payload";
+            readonly summary: "{method} {host}";
+        };
+        readonly slack: {
+            readonly sub: "Channel · add a webhook URL";
+            readonly summary: "Slack · {host}";
+        };
+        readonly wait: {
+            readonly title: "Wait / delay";
+            readonly sub: "Pause for {duration}";
+        };
+        readonly stop: {
+            readonly title: "Stop workflow";
+            readonly sub: "Ends the run";
+        };
+        readonly condition: {
+            readonly empty: "Set a condition";
+        };
+        readonly trigger: {
+            readonly record: "When a record is {event} in {table}";
+            readonly interval: "Every {minutes} minutes";
+            readonly daily: "Daily at {time}";
+            readonly weekly: "Weekly on {day} at {time}";
+            readonly monthly: "Monthly on day {day} at {time}";
+            readonly sub: "Trigger · {event}";
+        };
+    };
+    readonly event: {
+        readonly created: "created";
+        readonly updated: "updated";
+        readonly deleted: "deleted";
+    };
+    readonly insp: {
+        readonly stepName: "Step name";
+        readonly description: "Description";
+        readonly condition: "Condition";
+        readonly lookAt: "Look at";
+        readonly thisRecord: "This record";
+        readonly related: "Related records";
+        readonly field: "Field";
+        readonly value: "Value";
+        readonly countOf: "Count of";
+        readonly where: "where";
+        readonly isThisRecords: "is this record's";
+        readonly andWhere: "and where";
+        readonly branchLabels: "Branch labels";
+        readonly onError: "Continue on error";
+        readonly onErrorBody: "Run later steps even if this one fails";
+        readonly moveUp: "Move up";
+        readonly moveDown: "Move down";
+        readonly duplicate: "Duplicate";
+        readonly delete: "Delete";
+        readonly close: "Close";
+        readonly settings: "Settings";
+    };
+    readonly op: {
+        readonly is: "is";
+        readonly isNot: "is not";
+        readonly contains: "contains";
+        readonly gt: "is greater than";
+        readonly lt: "is less than";
+        readonly isEmpty: "is empty";
+        readonly notEmpty: "is not empty";
+        readonly withinNext: "is within the next";
+        readonly withinLast: "is within the last";
+        readonly moreThanAgo: "was more than … ago";
+        readonly moreThanAhead: "is more than … from now";
+    };
+    readonly unit: {
+        readonly minutes: "{count, plural, one {minute} other {minutes}}";
+        readonly hours: "{count, plural, one {hour} other {hours}}";
+        readonly days: "{count, plural, one {day} other {days}}";
+    };
+    readonly trig: {
+        readonly title: "Trigger";
+        readonly kind: "When";
+        readonly record: "A record is {event}";
+        readonly schedule: "On a schedule";
+        readonly table: "Table";
+        readonly changed: "Only when this column changes";
+        readonly anyColumn: "Any column";
+        readonly watch: {
+            readonly on: "Also watches for rows written outside Adminium · every minute · via {column}";
+            readonly off: "Watching is off: this table has no {shape}-shaped column or increasing key, so only writes made through Adminium trigger this rule";
+            readonly deleted: "Deleted rows cannot be watched; only deletes made through Adminium trigger this rule";
+            readonly fromNow: "Rows from now on";
+        };
+        readonly when: "Only when";
+        readonly every: "Every";
+        readonly at: "At";
+        readonly timezone: "Timezone";
+        readonly forEach: "For each record of";
+        readonly forEachWhere: "where";
+        readonly noTable: "No table — one run per tick";
+        readonly once: "Once per record";
+        readonly onceBody: "A record that matched before is not run again";
+        readonly timeSaved: "Time saved per run";
+        readonly timeSavedBody: "Minutes a person would have spent — shown as “saves” on the rule";
+        readonly addCondition: "Add a condition";
+        readonly connection: "Connection";
+    };
+    readonly sched: {
+        readonly interval: "Interval";
+        readonly daily: "Daily";
+        readonly weekly: "Weekly";
+        readonly monthly: "Monthly";
+    };
+    readonly email: {
+        readonly template: "Template";
+        readonly to: "To";
+        readonly toField: "This record's email";
+        readonly toFixed: "Addresses";
+        readonly column: "Column";
+        readonly addresses: "Add an address…";
+    };
+    readonly notif: {
+        readonly to: "Send to";
+        readonly roles: "Everyone with a role";
+        readonly users: "Specific people";
+        readonly title: "Title";
+        readonly body: "Message";
+    };
+    readonly rec: {
+        readonly table: "Table";
+        readonly values: "Values";
+        readonly addValue: "Add a value";
+        readonly column: "Column";
+        readonly value: "Value";
+        readonly now: "Now";
+        readonly remove: "Remove this value";
+        readonly tokenHint: "Use {token} to copy from the record";
+    };
+    readonly hook: {
+        readonly url: "URL";
+        readonly method: "Method";
+        readonly body: "Body";
+        readonly bodyJson: "JSON (event, rule, record)";
+        readonly bodyText: "Custom text";
+        readonly header: "Header";
+        readonly headerName: "Name";
+        readonly headerValue: "Value";
+        readonly slackUrl: "Slack webhook URL";
+        readonly slackText: "Message";
+    };
+    readonly wait: {
+        readonly for: "Wait for";
+        readonly max: "Up to 30 days";
+        readonly amount: "Amount";
+        readonly unit: "Unit";
+    };
+    readonly modal: {
+        readonly title: "New rule";
+        readonly subtitle: "Trigger workflows automatically when things happen.";
+        readonly name: "Rule name";
+        readonly namePlaceholder: "e.g. Welcome new signups";
+        readonly when: "When (trigger)";
+        readonly then: "Then (action)";
+        readonly enable: "Enable immediately";
+        readonly enableBody: "Start running as soon as the rule is created";
+        readonly cancel: "Cancel";
+        readonly create: "Create rule";
+        readonly doneTitle: "Rule created";
+        readonly doneBody: "Your rule is live and will run the next time it's triggered.";
+        readonly savedTitle: "Rule saved";
+        readonly savedBody: "Finish its steps, then switch it on.";
+        readonly done: "Done";
+        readonly trigger: {
+            readonly recordCreated: "A record is created";
+            readonly recordUpdated: "A record is updated";
+            readonly recordDeleted: "A record is deleted";
+            readonly schedule: "On a schedule";
+        };
+        readonly connection: "{connection} · {table}";
+        readonly tablePlaceholder: "Search tables…";
+        readonly tableEmpty: "No matching table";
+    };
+    readonly logs: {
+        readonly title: "Workflow logs";
+        readonly subtitle: "Execution history for your automations.";
+        readonly refresh: "Refresh";
+        readonly kpi: {
+            readonly runsToday: "Runs today";
+            readonly success: "Success rate";
+            readonly failed: "Failed";
+            readonly avgDuration: "Avg. duration";
+        };
+        readonly filter: {
+            readonly all: "All";
+            readonly success: "Success";
+            readonly failed: "Failed";
+            readonly running: "Running";
+        };
+        readonly status: {
+            readonly success: "Success";
+            readonly failed: "Failed";
+            readonly running: "Running";
+            readonly pending: "Starts {when}";
+            readonly waiting: "Waiting · resumes {when}";
+            readonly skipped: "Skipped";
+            readonly cancelled: "Cancelled";
+        };
+        readonly trigger: "Trigger";
+        readonly duration: "Duration";
+        readonly started: "Started";
+        readonly trace: "Execution trace";
+        readonly loadOlder: "Load older";
+        readonly empty: {
+            readonly title: "No runs yet";
+            readonly filtered: "No {status} runs in the last 7 days";
+        };
+        readonly select: "Select a run to see its trace";
+        readonly justNow: "just now";
+    };
+    readonly trace: {
+        readonly trigger: "record = {label} · {summary}";
+        readonly scheduleTick: "tick · {stamp}";
+        readonly evaluated: "evaluated → {result}";
+        readonly stopped: "evaluated → false · stopped";
+        readonly branch: "took “{label}”";
+        readonly wait: "resumes {stamp}";
+        readonly wouldWait: "Would wait {duration}";
+        readonly email: {
+            readonly ok: "{smtp} · delivered to {to}";
+            readonly fail: "ERROR · {reason}";
+            readonly would: "Would send “{subject}” to {to}";
+            readonly noSmtp: "SMTP is not configured — Settings → Email";
+            readonly noRecipient: "No recipient: {column} is empty";
+        };
+        readonly notif: {
+            readonly ok: "notified {count, plural, one {# person} other {# people}}";
+        };
+        readonly create: {
+            readonly ok: "created {label}";
+        };
+        readonly update: {
+            readonly ok: "set {pairs}";
+        };
+        readonly write: {
+            readonly would: "Would set {pairs}";
+        };
+        readonly hook: {
+            readonly ok: "{method} {path} → {status} · {ms}ms";
+            readonly fail: "{method} {path} → {status}";
+            readonly would: "Would {method} {url}";
+        };
+        readonly stop: "Stopped here";
+        readonly undone: "Undone before it ran";
+        readonly gone: "Record no longer exists";
+        readonly ruleOff: "Rule was switched off while waiting";
+        readonly skipped: "—";
+        readonly document: {
+            readonly ok: "document drawn · {number}";
+            readonly skipped: "no document drawn · {reason}";
+            readonly would: "Would draw {kind} · {name}";
+            readonly off: "mapping is switched off · {name}";
+        };
+    };
+    readonly dur: {
+        readonly ms: "{ms}ms";
+        readonly s: "{s}s";
+        readonly none: "—";
+    };
+    readonly saved: {
+        readonly h: "{h}h";
+        readonly m: "{m}m";
+    };
+};
+export default _default;
+//# sourceMappingURL=automations.d.ts.map

package/dist/resources/en-us/automations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automations.d.ts","sourceRoot":"","sources":["../../../src/resources/en-us/automations.ts"],"names":[],"mappings":"AACA;;;;;;;;GAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACH,wBAqZW"}