@adminiumjs/i18n 0.1.0-rc.1

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

@@ -0,0 +1,1964 @@
+/**
+ * GENERATED MIRROR of ../../../locales/en-US/common.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 bundles en-US resources (and chunk-splits
+ * the other locales) 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 common: {
+        readonly dismiss: "Dismiss";
+        readonly notifications: "Notifications";
+        readonly retry: "Retry";
+        readonly undo: "Undo";
+        readonly close: "Close";
+        readonly cancel: "Cancel";
+        readonly back: "Back";
+        readonly loading: "Loading";
+        readonly clearSearch: "Clear search";
+        readonly clear: "Clear";
+        readonly save: "Save";
+    };
+    readonly auth: {
+        readonly headline: "Turn any database into a dashboard.";
+        readonly trust: "AGPL core · Self-hosted · Your data stays yours";
+        readonly signIn: {
+            readonly title: "Welcome back";
+            readonly subtitle: "Sign in to your Adminium workspace.";
+            readonly email: "Email";
+            readonly emailInvalid: "Enter a valid email address.";
+            readonly password: "Password";
+            readonly passwordRequired: "Enter your password.";
+            readonly showPassword: "Show password";
+            readonly hidePassword: "Hide password";
+            readonly remember: "Keep me signed in";
+            readonly forgot: "Forgot?";
+            readonly submit: "Sign in";
+            readonly invalid: "Invalid email or password.";
+            readonly rateLimited: "Too many attempts — try again in a minute.";
+            readonly failed: "Sign-in failed. Check your connection and try again.";
+        };
+        readonly forgot: {
+            readonly title: "Reset your password";
+            readonly email: "Email";
+            readonly emailInvalid: "Enter a valid email address.";
+            readonly submit: "Send reset link";
+            readonly sentTitle: "Check your email";
+            readonly resend: "Send it again";
+            readonly back: "Back to sign in";
+            readonly done: "Back to sign in";
+            readonly rateLimited: "Too many requests — try again later.";
+            readonly failed: "Something went wrong. Try again.";
+            readonly smtpUnconfigured: "This Adminium has no email server configured, so it cannot send a reset link. Ask an administrator to reset your password for you.";
+        };
+        readonly reset: {
+            readonly title: "Set a new password";
+            readonly subtitle: "Must be at least 8 characters.";
+            readonly password: "New password";
+            readonly confirm: "Confirm password";
+            readonly showPassword: "Show password";
+            readonly hidePassword: "Hide password";
+            readonly strength: "Password strength";
+            readonly weak: "Weak";
+            readonly fair: "Fair";
+            readonly good: "Good";
+            readonly strong: "Strong";
+            readonly tooShort: "Use at least 8 characters.";
+            readonly submit: "Reset password";
+            readonly failed: "Reset failed. Try again.";
+        };
+        readonly otp: {
+            readonly title: "Two-factor authentication";
+            readonly subtitle: "Enter the 6-digit code from your authenticator app.";
+            readonly code: "One-time code";
+            readonly recoveryCode: "Recovery code";
+            readonly useRecovery: "Lost your device? Use a recovery code";
+            readonly useAuthenticator: "Use your authenticator app instead";
+            readonly submit: "Verify";
+            readonly invalid: "That code didn’t work. Try again.";
+            readonly failed: "Verification failed. Check your connection and try again.";
+        };
+    };
+    readonly nav: {
+        readonly home: "Home";
+        readonly primary: "Primary";
+        readonly account: "Account";
+        readonly signOut: "Sign out";
+        readonly empty: "Pages appear here once a database is connected.";
+        readonly connection: {
+            readonly shared: "Shared";
+            readonly unnamed: "Connection";
+        };
+        readonly imports: "Import data";
+        readonly exports: "Data exports";
+        readonly emailTemplates: "Email templates";
+        readonly notificationSettings: "Notification settings";
+        readonly scheduledReports: "Scheduled reports";
+        readonly group: {
+            readonly workspace: "Workspace";
+            readonly library: "Library";
+            readonly planning: "Planning";
+            readonly people: "People";
+            readonly account: "Account";
+        };
+    };
+    readonly topbar: {
+        readonly search: "Search…";
+        readonly notifications: "Notifications";
+        readonly notificationsLoading: "Loading notifications";
+        readonly notificationsError: "Couldn’t load notifications.";
+        readonly notificationsEmpty: "You’re all caught up.";
+        readonly theme: "Toggle light / dark";
+        readonly userMenu: "Account menu";
+        readonly profile: "Profile";
+        readonly preferences: "Preferences";
+        readonly signOut: "Sign out";
+    };
+    readonly palette: {
+        readonly dialog: "Command palette";
+        readonly placeholder: "Type a command or search…";
+        readonly navigate: "Navigate";
+        readonly actions: "Actions";
+        readonly askAi: "Ask AI";
+        readonly shortcuts: "Keyboard shortcuts";
+        readonly signOut: "Sign out";
+        readonly themeDark: "Switch to dark theme";
+        readonly themeLight: "Switch to light theme";
+        readonly footerNavigate: "navigate";
+        readonly footerOpen: "select";
+        readonly footerClose: "close";
+    };
+    readonly shortcuts: {
+        readonly title: "Keyboard shortcuts";
+        readonly subtitle: "Work faster across Adminium";
+        readonly close: "Close";
+        readonly dismiss: "Close or dismiss";
+        readonly palette: "Open command palette";
+        readonly panel: "Show shortcuts panel";
+        readonly search: "Focus search";
+        readonly sidebar: "Toggle sidebar";
+        readonly theme: "Toggle light / dark";
+        readonly then: "then";
+        readonly footerPre: "Press";
+        readonly footerPost: "anytime to open this panel.";
+    };
+    readonly states: {
+        readonly checked: "checked 8s ago";
+        readonly diagnostics: "Diagnostics";
+    };
+    readonly notFound: {
+        readonly title: "This page went missing";
+        readonly errorLine: "Error 404";
+        readonly searchPlaceholder: "Search for a page…";
+        readonly matches: "Matching pages";
+        readonly popular: "Popular destinations";
+        readonly goBack: "Go back";
+        readonly backToDashboard: "Back to dashboard";
+    };
+    readonly page: {
+        readonly invalid: {
+            readonly title: "This page’s configuration is invalid";
+            readonly body: "The stored page document failed validation and cannot be rendered.";
+        };
+        readonly renderError: {
+            readonly title: "This page failed to render";
+        };
+        readonly tooNew: {
+            readonly title: "This page needs a newer Adminium";
+        };
+        readonly unknownTemplate: {
+            readonly title: "Unknown page template";
+        };
+    };
+    readonly mutation: {
+        readonly created: "Record created";
+        readonly updated: "Record updated";
+        readonly deleted: "Record deleted";
+    };
+    readonly undo: {
+        readonly done: "Change undone";
+        readonly failed: "Could not undo this change";
+    };
+    readonly prefs: {
+        readonly theme: {
+            readonly label: "Theme";
+            readonly light: "Light";
+            readonly dark: "Dark";
+            readonly system: "System";
+        };
+        readonly accent: {
+            readonly label: "Accent color";
+            readonly indigo: "Indigo";
+            readonly blue: "Blue";
+            readonly teal: "Teal";
+            readonly violet: "Violet";
+            readonly rose: "Rose";
+            readonly red: "Red";
+            readonly orange: "Orange";
+            readonly black: "Black";
+        };
+        readonly density: {
+            readonly label: "Density";
+            readonly comfortable: "Comfortable";
+            readonly compact: "Compact";
+        };
+        readonly locale: {
+            readonly label: "Language";
+            readonly directionNote: "Text direction: right to left (set automatically by the language)";
+        };
+    };
+    readonly account: {
+        readonly title: "Account";
+        readonly subtitle: "The identity of your current session. Manage display preferences and notification settings on their dedicated pages.";
+        readonly preferencesLink: "Preferences";
+        readonly notificationsLink: "Notification settings";
+        readonly name: "Name";
+        readonly email: "Email";
+        readonly roles: "Roles";
+        readonly twoFactor: "Two-factor";
+        readonly on: "Enabled";
+        readonly off: "Off";
+        readonly preferences: {
+            readonly title: "Preferences";
+            readonly subtitle: "How Adminium looks and reads for you — on this and every device you sign in from.";
+            readonly workspaceDefault: "Workspace default";
+            readonly personal: "Personal";
+            readonly usingDefault: "Using workspace default ({value})";
+            readonly reset: "Reset to workspace default";
+            readonly resetFailed: "Could not reset this preference. Try again.";
+            readonly appliesInstantly: "Changes apply instantly and are saved to your profile.";
+        };
+    };
+    readonly settings: {
+        readonly defaults: {
+            readonly title: "Global defaults";
+            readonly subtitle: "Workspace-wide appearance and language defaults.";
+            readonly explainer: "These defaults apply to all users unless they override them. Anyone can set their own preference under Profile → Preferences — personal preferences always win for that user.";
+            readonly appearanceHeading: "Appearance defaults";
+            readonly languageHeading: "Language & region defaults";
+            readonly adoption: "{following, number} of {total, plural, one {# user} other {# users}} follow this default.";
+            readonly weekStartNote: "Week start and number formats follow the language.";
+            readonly save: "Save defaults";
+            readonly saved: "Workspace defaults updated";
+            readonly saveFailed: "Could not save workspace defaults. Try again.";
+            readonly liveNote: "Saving broadcasts the change live — signed-in users who follow a default see it apply without a reload.";
+        };
+        readonly notifications: {
+            readonly subtitle: "Choose what you’re notified about and how";
+            readonly matrixLabel: "Notify me about";
+            readonly rowHeader: "Event";
+            readonly saving: "Saving…";
+            readonly saved: "Saved";
+            readonly unavailable: "Not available yet";
+            readonly loading: "Loading preferences";
+            readonly errorTitle: "These settings failed to load";
+            readonly emptyTitle: "Nothing to configure yet";
+            readonly emptyBody: "Notification events appear here as producers ship.";
+            readonly saveFailed: "Could not save this change.";
+        };
+    };
+    readonly studio: {
+        readonly source: {
+            readonly engine: {
+                readonly label: "Database engine";
+                readonly postgres: "PostgreSQL";
+                readonly mysql: "MySQL / MariaDB";
+                readonly sqlite: "SQLite";
+            };
+            readonly format: {
+                readonly label: "Schema format";
+                readonly helper: "Leave on auto-detect unless the detection gets it wrong.";
+                readonly auto: "Auto-detect";
+                readonly sql: "SQL DDL / pg_dump";
+                readonly prisma: "Prisma schema";
+                readonly drizzle: "Drizzle ORM";
+                readonly typeorm: "TypeORM entities";
+                readonly sequelize: "Sequelize models";
+                readonly rails: "Rails schema.rb";
+                readonly django: "Django models.py";
+                readonly json: "Adminium JSON";
+            };
+            readonly sqlite: {
+                readonly file: "Database file path";
+                readonly helper: "SQLite is a file, not a server — give the absolute path on the machine running Adminium.";
+            };
+            readonly file: {
+                readonly detectedAs: "Detected: {format}";
+                readonly moreWarnings: "+{count} more warnings — the full list appears in the analyze step.";
+                readonly dropTitle: "Drop your schema file here, or browse";
+                readonly dropHint: "SQL DDL / pg_dump, Prisma, Drizzle, TypeORM, Sequelize, Rails schema.rb, Django models, Adminium JSON";
+                readonly pitch: "No database connection required — we parse your schema file and build the same dashboards.";
+                readonly parsing: "Reading uploaded schema file…";
+                readonly tables: "tables";
+                readonly columns: "columns";
+                readonly warnings: "warnings";
+                readonly errorTitle: "Could not parse the file";
+                readonly parseFailed: "We could not parse that file. If auto-detect guessed wrong, pick the format explicitly and retry.";
+                readonly unsupported: "That format is not recognized — SQL DDL, Prisma, Drizzle, TypeORM, Sequelize, Rails schema.rb, Django models and Adminium JSON are supported. Pick one explicitly and retry.";
+                readonly requestFailed: "Upload failed — check your connection and try again.";
+            };
+            readonly title: "Connect your database";
+            readonly subtitle: "Point Adminium at a database and we'll generate an admin dashboard from its schema.";
+            readonly name: "Connection name";
+            readonly namePlaceholder: "Production Postgres";
+            readonly modeLabel: "Source input mode";
+            readonly mode: {
+                readonly dsn: "Connection string";
+                readonly fields: "Individual fields";
+                readonly file: "Schema file";
+            };
+            readonly dsn: {
+                readonly label: "Connection string";
+                readonly helper: "postgres://user:password@host:5432/database — mysql:// and sqlite: work too.";
+                readonly incomplete: "Add host and database, e.g. postgres://user@host:5432/db";
+                readonly invalidScheme: "Unrecognized scheme — expected postgres://, mysql://, mariadb:// or sqlite:";
+                readonly quickFill: "Quick fill:";
+            };
+            readonly fields: {
+                readonly host: "Host";
+                readonly port: "Port";
+                readonly database: "Database";
+                readonly user: "User";
+                readonly password: "Password";
+                readonly ssl: "SSL mode";
+                readonly preview: "Connection string preview:";
+            };
+            readonly readOnlyRole: {
+                readonly title: "Use a read-only role";
+                readonly body: "Adminium never writes to your database — setup uses schema metadata only. We recommend a dedicated user with SELECT-only grants; you can decide where Adminium keeps its own tables in the meta-storage step.";
+            };
+        };
+        readonly capability: {
+            readonly mysqlApproxRows: "MySQL row counts are storage-engine estimates (they can drift up to ±40%) — shown with ≈.";
+            readonly mysqlFkEnum: "MySQL FK/enum metadata is weaker: MyISAM tables declare no foreign keys, enums are per-column enum(…) types, and CHECK constraints need MySQL 8.0.16+ / MariaDB 10.2+.";
+            readonly sqliteCheckEnums: "SQLite has no native enum type — enums are synthesized from CHECK (col IN (…)) constraints.";
+            readonly sqliteNoComments: "SQLite has no column comments — use the schema remap editor to add labels.";
+            readonly importNoRowCounts: "Schema files carry no row counts — the tables list shows — instead of made-up numbers.";
+            readonly importNoLiveHealth: "No live database connection — health checks and schema-drift detection are unavailable for this source.";
+            readonly rowsUnavailable: "Schema files have no live database — row counts are unknown until you connect one.";
+            readonly rowsRunAnalyze: "No estimate yet — run ANALYZE on the database for row counts.";
+            readonly rowsNoEstimate: "The engine reported no estimate for this table.";
+            readonly rowsApproximate: "Storage-engine estimate — can drift up to ±40% on InnoDB.";
+        };
+        readonly test: {
+            readonly log: {
+                readonly moreWarnings: "+{count} more parser warnings";
+                readonly connecting: "Establishing secure connection…";
+                readonly connected: "Connected ({latency} ms) · read-only introspection";
+                readonly connectFailed: "Connection failed.";
+                readonly readingSchema: "Reading schema: public";
+                readonly readingFile: "Reading uploaded schema file…";
+                readonly parsingFile: "Parsing {file}…";
+                readonly detected: "Detected {tables} tables · {columns} columns";
+                readonly found: "Found {tables} tables · {columns} columns";
+                readonly mapping: "Mapping column types → input widgets";
+                readonly relations: "Detecting relations…";
+                readonly piiScan: "Scanning for PII columns…";
+                readonly piiDone: "PII scan complete — {count} columns masked by default";
+                readonly piiDoneUnknown: "PII scan complete";
+                readonly jobFailed: "Introspection failed.";
+                readonly networkFailed: "Request failed — check your connection and retry.";
+                readonly ready: "Ready";
+            };
+            readonly title: "Analyzing your schema";
+            readonly subtitle: "Introspecting tables, columns, and relationships. This takes a few seconds.";
+            readonly trust: "We only read your schema and data. Nothing is modified.";
+            readonly errorTitle: "Connection failed";
+            readonly retry: "Retry";
+            readonly logLabel: "Introspection log";
+            readonly hint: {
+                readonly auth: "Authentication failed — check the user name and password in your DSN.";
+                readonly hostUnreachable: "Host unreachable — check the hostname and port, and that the database accepts connections from this machine (allowlist our IPs).";
+                readonly metaPlacement: "This source cannot host Adminium’s meta tables — continue with a separate meta database.";
+                readonly permission: "The role connected but lacks schema-read privileges — grant USAGE on the schema to your introspection role.";
+                readonly timeout: "The database did not answer in time — check network path and load, then retry.";
+                readonly tls: "TLS negotiation failed — try sslmode=require, or upload the CA certificate your server expects.";
+                readonly unknown: "Connection failed — verify the DSN and retry.";
+            };
+        };
+        readonly tables: {
+            readonly importNoCounts: "Schema files carry no row counts — the column shows — until a live database is connected.";
+            readonly title: "Choose your tables";
+            readonly subtitle: "Choose which to include. You can change this anytime.";
+            readonly search: "Filter tables…";
+            readonly listLabel: "Includable tables";
+            readonly emptyFilter: "No tables match your filter.";
+            readonly pii: "PII";
+            readonly highVolume: "high volume";
+            readonly highVolumeNote: "Tables over 100,000 rows start unchecked — ops tables rarely belong in a dashboard.";
+            readonly joinHidden: "{count} join/system tables are pre-hidden — they still power many-to-many relations.";
+        };
+        readonly hub: {
+            readonly title: "Data connections";
+            readonly subtitle: "{healthy, number} of {total, plural, one {# connection} other {# connections}} healthy";
+            readonly connectNew: "New connection";
+            readonly stats: {
+                readonly connections: "Connections";
+                readonly healthy: "Healthy";
+                readonly tables: "Tables included";
+                readonly pages: "Generated pages";
+            };
+            readonly status: {
+                readonly connected: "Connected";
+                readonly error: "Error";
+                readonly unconfigured: "Draft";
+                readonly testing: "Testing…";
+            };
+            readonly card: {
+                readonly readOnly: "Read-only";
+                readonly tables: "Tables";
+                readonly pages: "Pages";
+                readonly latency: "Latency";
+                readonly latencyMs: "{latency, number} ms";
+                readonly lastIntrospected: "Last introspected";
+                readonly never: "Never";
+            };
+            readonly action: {
+                readonly test: "Test";
+                readonly reintrospect: "Re-introspect";
+                readonly reintrospectFile: "Schema-file sources have no live database — re-upload the file instead.";
+                readonly remap: "Remap schema";
+                readonly delete: "Delete";
+            };
+            readonly test: {
+                readonly ok: "Connection healthy · {latency, number} ms";
+                readonly failed: "Connection test failed";
+            };
+            readonly introspect: {
+                readonly noChanges: "Schema unchanged — no new snapshot.";
+                readonly updated: "Schema re-introspected";
+                readonly masksProposed: "{count, plural, one {# column} other {# columns}} proposed for masking — review in the remap editor.";
+                readonly failed: "Introspection failed. Try again.";
+            };
+            readonly delete: {
+                readonly title: "Delete connection";
+                readonly body: "This deletes “{name}” and its generated pages. Your database itself is never touched.";
+                readonly prompt: "Type {name} to confirm";
+                readonly confirm: "Delete connection";
+                readonly cancel: "Cancel";
+                readonly close: "Close";
+                readonly success: "Connection “{name}” deleted";
+                readonly failed: "Could not delete the connection. Try again.";
+            };
+            readonly empty: {
+                readonly title: "No data sources yet";
+                readonly body: "Connect a database and Adminium generates your admin panel from its schema.";
+                readonly cta: "Connect a database";
+            };
+        };
+        readonly settingsHub: {
+            readonly title: "Workspace settings";
+            readonly subtitle: "Identity, security and destructive actions for this workspace.";
+            readonly save: "Save changes";
+            readonly saved: "Workspace settings updated";
+            readonly saveFailed: "Could not save workspace settings. Try again.";
+            readonly superAdminOnlyTitle: "Super admin required";
+            readonly superAdminOnly: "Only a super admin can change workspace identity and security settings.";
+            readonly identity: {
+                readonly heading: "Workspace identity";
+                readonly appName: {
+                    readonly label: "Application name";
+                    readonly helper: "Shown in the sidebar, browser title, and emails.";
+                    readonly error: "Enter a name of at most 60 characters.";
+                };
+            };
+            readonly security: {
+                readonly heading: "Security";
+                readonly require2fa: {
+                    readonly label: "Require two-factor auth";
+                    readonly desc: "Every member must enable 2FA to sign in.";
+                };
+                readonly allowSignup: {
+                    readonly label: "Allow self-signup";
+                    readonly desc: "Anyone can create an account — off keeps this workspace invite-only.";
+                };
+                readonly sessionTtl: {
+                    readonly label: "Session lifetime (hours)";
+                    readonly error: "Between {min, number} and {max, number} hours.";
+                };
+                readonly passwordMin: {
+                    readonly label: "Minimum password length";
+                    readonly error: "Between {min, number} and {max, number} characters.";
+                };
+            };
+            readonly review: {
+                readonly title: "Save workspace settings";
+                readonly subtitle: "Review your changes before saving.";
+                readonly confirm: "Save changes";
+                readonly cancel: "Cancel";
+                readonly close: "Close";
+                readonly on: "On";
+                readonly off: "Off";
+                readonly change: "{before} → {after}";
+            };
+            readonly defaultsCard: {
+                readonly heading: "Appearance & language defaults";
+                readonly body: "Workspace-wide theme, accent, density and language live under Global defaults.";
+                readonly cta: "Open global defaults";
+            };
+            readonly danger: {
+                readonly heading: "Danger zone";
+                readonly subtitle: "Irreversible actions.";
+                readonly empty: "Nothing to delete — no connections yet.";
+                readonly deleteDesc: "Deletes the connection and its generated pages. Your database is not touched. Cannot be undone.";
+                readonly deleteCta: "Delete connection";
+            };
+            readonly aiCard: {
+                readonly heading: "AI enrichment";
+                readonly body: "Configure an AI provider (or the copy-paste round-trip) to enrich labels, groups and relations.";
+                readonly cta: "Open AI settings";
+            };
+        };
+        readonly settingsAi: {
+            readonly title: "AI enrichment";
+            readonly subtitle: "Connect a model to let Adminium suggest labels, groups, relations and more — always reviewed as a diff before anything applies.";
+            readonly saved: "AI provider saved";
+            readonly saveFailed: "Could not save the AI provider. Try again.";
+            readonly save: "Save provider";
+            readonly test: "Test connection";
+            readonly testHintDirty: "Save your changes before testing.";
+            readonly testing: "Pinging the provider…";
+            readonly testError: "Test failed";
+            readonly testErrorBody: "Could not reach the provider. Check the key and base URL.";
+            readonly testOk: "Connected to {model} in {latency} ms";
+            readonly testUnknownModel: "the provider";
+            readonly provider: {
+                readonly heading: "AI provider";
+                readonly subtitle: "Choose how Adminium reaches a model to enrich your schema. Keys are stored encrypted and never shown again.";
+                readonly active: "Active";
+                readonly anthropic: {
+                    readonly label: "Anthropic";
+                    readonly desc: "Claude models via the Anthropic API.";
+                };
+                readonly openai: {
+                    readonly label: "OpenAI";
+                    readonly desc: "GPT models via the OpenAI API.";
+                };
+                readonly openaiCompatible: {
+                    readonly label: "OpenAI-compatible";
+                    readonly desc: "Any endpoint that speaks the OpenAI wire format — Groq, Together, vLLM, LM Studio.";
+                };
+                readonly ollama: {
+                    readonly label: "Ollama (local)";
+                    readonly desc: "Models running locally through Ollama — no key, no cloud.";
+                };
+                readonly requiresNetwork: "Requires internet & an API key";
+                readonly networkDisabledTitle: "Direct AI providers are turned off on this install";
+                readonly networkDisabledBody: "This Adminium is configured with no outbound internet access, so it cannot reach a provider API. Use the copy-paste round-trip below — it needs no key and no network.";
+            };
+            readonly configure: {
+                readonly heading: "Configure {provider}";
+            };
+            readonly field: {
+                readonly baseUrl: "Base URL";
+                readonly baseUrlOptional: "Leave as-is unless Ollama runs on another host.";
+                readonly baseUrlHelper: "The endpoint root that serves /chat/completions.";
+                readonly model: "Model";
+                readonly modelFreeText: "Enter the exact model id your endpoint serves.";
+                readonly modelLive: "Loaded live from the provider.";
+                readonly modelStatic: "A known-good list; type a custom id after saving to refresh it.";
+                readonly modelLoading: "Loading…";
+                readonly modelPlaceholder: "Select a model…";
+                readonly key: "API key";
+                readonly keyStored: "Stored encrypted. Replace it to use a different key.";
+                readonly keyMask: "sk-…{last4}";
+                readonly keyReplace: "Replace key";
+                readonly keyOptional: "Optional — some endpoints need no key.";
+                readonly keyWriteOnly: "Write-only: once saved it is never shown again.";
+                readonly noKeyTitle: "No API key needed";
+                readonly noKeyBody: "Ollama runs locally, so nothing leaves this machine.";
+            };
+            readonly runStatus: {
+                readonly draft: "Draft";
+                readonly running: "Running";
+                readonly awaitingResponse: "Awaiting response";
+                readonly validated: "Validated";
+                readonly applied: "Applied";
+                readonly partiallyApplied: "Partially applied";
+                readonly failed: "Failed";
+                readonly discarded: "Discarded";
+            };
+            readonly byo: {
+                readonly heading: "No key? Use your own AI tool";
+                readonly subtitle: "The copy-paste round-trip — nothing leaves this machine.";
+                readonly body: "Studio can generate a self-contained prompt from your schema. Run it in Claude Code, ChatGPT, or any tool you like, then paste the JSON it returns back into the connect wizard. Same validation, same review, same result as the direct path.";
+                readonly guaranteeTitle: "Telemetry-free guarantee";
+                readonly guarantee1: "The prompt carries only your schema and aggregate stats — never row data by default.";
+                readonly guarantee2: "No credentials, instance URL, or identifiers are embedded.";
+                readonly guarantee3: "BYO runs make zero network calls.";
+                readonly promptVersion: "Prompt {version}";
+                readonly schemaVersion: "Schema {version}";
+                readonly headingRecommended: "Use your own AI tool — no key needed";
+                readonly recommended: "Recommended";
+            };
+            readonly history: {
+                readonly heading: "Run history";
+                readonly subtitle: "Past enrichment runs. Open one to review its suggestions.";
+                readonly tableLabel: "Enrichment runs";
+                readonly colDate: "Date";
+                readonly colSource: "Source";
+                readonly colStatus: "Status";
+                readonly colChunks: "Chunks";
+                readonly openReview: "Open review for the run from {date}";
+                readonly connection: "Connection";
+                readonly empty: "No enrichment runs yet. Enrich a schema from the connect wizard to see history here.";
+                readonly errorTitle: "Could not load runs";
+                readonly errorBody: "Refresh the page to try again.";
+                readonly noConnections: "Connect a database first — enrichment runs are recorded per connection.";
+                readonly byo: "BYO";
+                readonly directPath: "Direct";
+            };
+        };
+        readonly enrich: {
+            readonly title: "Enrich with AI";
+            readonly subtitle: "Optionally refine the generated labels, groups, enums and dashboards with an LLM. The heuristic baseline works without it — this only adds suggestions you review before anything applies.";
+            readonly intentLabel: "How would you like to enrich?";
+            readonly sectionsLegend: "What should the AI decide?";
+            readonly localesLegend: "Translate labels into";
+            readonly localeLocked: "(required)";
+            readonly samplingTitle: "Include sample values";
+            readonly samplingHint: "Includes up to 20 real values per non-PII column in the prompt.";
+            readonly samplingPreviewTitle: "What leaves this machine";
+            readonly samplingPreviewBody: "Up to 20 most-common values per non-PII column, plus min/max for numeric and date columns. PII-flagged columns are never sampled. Everything else stays aggregate-only. Review the exact prompt before copying (BYO) — nothing is sent without your action.";
+            readonly noSections: "Select at least one decision group to enrich.";
+            readonly generatePrompt: "Generate prompt";
+            readonly startProvider: "Start enrichment";
+            readonly startOver: "Start over";
+            readonly copied: "Copied";
+            readonly createFailed: "Could not build the enrichment prompt — retry.";
+            readonly createFailedTitle: "Could not start";
+            readonly providerFallback: "your AI provider";
+            readonly fileTitle: "AI enrichment needs a live database";
+            readonly fileBody: "Schema-file sources have no snapshot to enrich yet. Connect a live database to use AI enrichment, or continue — the heuristic baseline still generates a complete app.";
+            readonly section: {
+                readonly labels: "Labels & descriptions";
+                readonly groups: "Navigation groups";
+                readonly enums: "Enum semantics";
+                readonly relations: "Relations";
+                readonly keys: "Key columns";
+                readonly templates: "Page templates";
+                readonly widgets: "Dashboard widgets";
+                readonly pii: "PII & masking";
+                readonly icons: "Icons";
+                readonly microcopy: "Micro-copy";
+            };
+            readonly provider: {
+                readonly title: "Use my AI provider";
+                readonly description: "Run enrichment now against your configured provider. You review every suggestion as a diff.";
+                readonly unconfigured: "No AI provider is configured yet — copy a prompt to your own tool below, or configure a provider first.";
+                readonly settingsHint: "Want to run it directly?";
+                readonly settingsLink: "Configure a provider in Settings → AI";
+                readonly networkDisabled: "This Adminium has no outbound internet access, so it cannot reach a provider API. Use the copy-paste round-trip instead — same prompt, same review.";
+            };
+            readonly byo: {
+                readonly cardTitle: "Copy a prompt to my own AI tool";
+                readonly cardDescription: "Copy a self-contained prompt into Claude Code, ChatGPT, anything — then paste the JSON back. No key needed, nothing leaves this machine automatically.";
+                readonly guidance: "Run this in any AI tool — Claude Code, ChatGPT, anything. Paste the JSON it returns below.";
+                readonly promptLabel: "Enrichment prompt";
+                readonly promptLabelN: "Enrichment prompt {index} of {total}";
+                readonly tokenChip: "≈ {tokens} tokens";
+                readonly copyPrompt: "Copy prompt";
+                readonly copyPromptDone: "Prompt copied";
+                readonly download: "Download .md";
+                readonly chunkTabs: "Prompt chunks";
+                readonly chunkTab: "Prompt {index}";
+                readonly chunkValid: "Chunk {index} validated";
+                readonly pasteLabel: "Paste the JSON response";
+                readonly pastePlaceholder: "Paste the JSON response here…";
+                readonly validate: "Validate";
+                readonly valid: "Response validated";
+                readonly mergedTitle: "All {count} chunks validated and merged";
+                readonly mergedTitleSingle: "Response validated";
+                readonly mergedBody: "Suggestions are ready to review against the heuristic baseline.";
+                readonly errorsTitle: "Validation found {count} issues";
+                readonly copyErrors: "Copy errors for your AI tool";
+                readonly copyErrorsDone: "Errors copied";
+                readonly copyErrorsHint: "Paste this back into your AI tool to get a corrected response.";
+                readonly droppedItems: "{count} suggestions were dropped during validation — review shows the rest.";
+                readonly pendingTitle: "Validate every prompt to continue";
+                readonly pendingBody: "Paste the JSON response above and validate it to continue to review.";
+                readonly pendingBodyChunked: "Each chunk must validate before the suggestions merge. Paste and validate every prompt above.";
+                readonly requestFailed: "Could not reach the server to validate — retry.";
+                readonly continueReview: "Continue to review";
+                readonly wholeDocument: "whole document";
+                readonly cardTitleRecommended: "Copy a prompt to my own AI tool — recommended";
+            };
+            readonly direct: {
+                readonly title: "Enriching with AI";
+                readonly subtitle: "Sending your schema to";
+                readonly building: "Building prompt…";
+                readonly logLabel: "Enrichment log";
+                readonly cancel: "Cancel";
+                readonly back: "Back to options";
+                readonly retry: "Retry";
+                readonly done: "Enrichment complete — review the suggestions.";
+                readonly continueReview: "Continue to review";
+                readonly failed: "The provider run failed. Check your AI settings and retry.";
+                readonly jobFailed: "The enrichment run did not finish.";
+                readonly startFailed: "Could not start the run — retry.";
+                readonly errorTitle: "Enrichment failed";
+            };
+            readonly skip: {
+                readonly title: "Skip — use heuristics only";
+                readonly description: "Generate from the heuristic baseline. You can enrich later from Settings → AI — skipping is never penalized.";
+                readonly confirmTitle: "Continuing with heuristics";
+                readonly confirmBody: "The generated app will use the heuristic labels, groups and dashboards. Continue to generate — you can run AI enrichment any time from Settings → AI.";
+            };
+        };
+        readonly review: {
+            readonly unavailableTitle: "Review screen not available";
+            readonly unavailableBody: "This build does not include the enrichment review screen yet (06-T14). It lands with the diff-and-apply flow.";
+        };
+        readonly llmRuns: {
+            readonly review: {
+                readonly header: {
+                    readonly title: "Review AI suggestions";
+                    readonly model: "Model";
+                    readonly snapshot: "Snapshot";
+                    readonly byo: "BYO";
+                    readonly pathDirect: "Direct API";
+                    readonly pathByo: "Copy-paste";
+                    readonly agree: "{n} agree";
+                    readonly conflict: "{n} conflict";
+                    readonly new: "{n} new";
+                    readonly rejects: "{n} rejects";
+                    readonly countsAria: "Suggestion counts";
+                };
+                readonly bulk: {
+                    readonly thresholdLabel: "Confidence threshold";
+                    readonly thresholdAria: "Accept-all confidence threshold";
+                    readonly acceptAll: "Accept all ≥ {pct}%";
+                    readonly clear: "Clear selection";
+                };
+                readonly section: {
+                    readonly selectAllAria: "Select all in {group}";
+                    readonly acceptedCount: "{n} accepted";
+                };
+                readonly group: {
+                    readonly labels: "Labels & translations";
+                    readonly navigation: "Navigation & domains";
+                    readonly enums: "Enum semantics";
+                    readonly relations: "Relations";
+                    readonly keys: "Key columns";
+                    readonly templates: "Page templates";
+                    readonly dashboards: "Dashboards & widgets";
+                    readonly pii: "PII & masking";
+                    readonly icons: "Icons";
+                    readonly microcopy: "Micro-copy";
+                };
+                readonly status: {
+                    readonly agree: "Agrees";
+                    readonly conflict: "Conflict";
+                    readonly new: "New";
+                    readonly heuristicOnly: "Heuristic only";
+                    readonly rejects: "Rejects heuristic";
+                    readonly locked: "Locked";
+                };
+                readonly row: {
+                    readonly acceptAria: "Accept {noun} suggestion for {target}";
+                    readonly keptEdited: "kept — edited by you";
+                    readonly rejectsCallout: "The AI rejects a heuristic decision — confirm before accepting.";
+                    readonly showTranslations: "Show translations";
+                    readonly hideTranslations: "Hide translations";
+                    readonly confidenceAria: "Confidence {pct}%";
+                    readonly noAi: "No AI suggestion";
+                };
+                readonly value: {
+                    readonly none: "No value";
+                    readonly absent: "None";
+                    readonly dash: "—";
+                    readonly display: "Display";
+                    readonly key: "Key";
+                    readonly rank: "rank {n}";
+                    readonly span: "span {n}";
+                    readonly tableCount: "{n} tables";
+                    readonly widgetCount: "{n} widgets";
+                    readonly enumWorkflow: "Workflow";
+                    readonly enumCategory: "Category";
+                    readonly notPii: "Not PII";
+                    readonly label: "Label";
+                    readonly description: "Description";
+                    readonly subtitle: "Page subtitle";
+                    readonly headline: "Empty-state headline";
+                    readonly guidance: "Empty-state guidance";
+                };
+                readonly apply: {
+                    readonly title: "Apply {n} suggestions";
+                    readonly subtitle: "These changes are written in one transaction and can be undone.";
+                    readonly empty: "Nothing selected to apply.";
+                    readonly confirm: "Apply changes";
+                };
+                readonly footer: {
+                    readonly count: "{n} suggestions selected";
+                    readonly apply: "Apply {n} accepted suggestions";
+                    readonly failed: "Apply failed";
+                };
+                readonly toast: {
+                    readonly applied: "Applied {n} suggestions";
+                    readonly appliedPartial: "Applied {n} suggestions (some skipped)";
+                    readonly applyFailed: "Could not apply suggestions";
+                    readonly undoFailed: "Could not undo this change";
+                };
+                readonly error: {
+                    readonly title: "Could not load this run";
+                };
+                readonly notReady: {
+                    readonly title: "This run has no suggestions to review yet";
+                    readonly body: "A run must be validated before its suggestions can be reviewed. Generate or paste a response first.";
+                };
+                readonly applied: {
+                    readonly title: "This run has been applied";
+                    readonly body: "The accepted suggestions below are read-only.";
+                };
+                readonly empty: {
+                    readonly title: "No suggestions";
+                    readonly body: "This run produced no suggestions to review.";
+                };
+                readonly cat: {
+                    readonly label: "label";
+                    readonly key: "key columns";
+                    readonly enum: "enum";
+                    readonly relation: "relation";
+                    readonly pii: "PII";
+                    readonly template: "page template";
+                    readonly group: "navigation group";
+                    readonly dashboard: "dashboard";
+                    readonly widget: "widget";
+                    readonly copy: "micro-copy";
+                };
+            };
+        };
+        readonly wizard: {
+            readonly title: "New connection";
+            readonly back: "Back";
+            readonly continue: "Continue";
+            readonly progress: "Setup progress";
+            readonly persistFailed: "Could not save your table selection — retry.";
+            readonly persistFailedTitle: "Save failed";
+            readonly step: {
+                readonly source: "Source";
+                readonly test: "Analyze";
+                readonly tables: "Tables";
+                readonly meta: "Meta storage";
+                readonly intent: "Intent";
+                readonly enrich: "Enrich";
+                readonly generate: "Generate";
+            };
+        };
+        readonly meta: {
+            readonly title: "Where should Adminium keep its own tables?";
+            readonly subtitle: "Pages, roles, audit log and settings live in adminium_-prefixed tables — never mixed into your data.";
+            readonly sameDb: {
+                readonly title: "Same database";
+                readonly description: "adminium_* tables are created beside your source tables. Simplest setup — needs a role with write and CREATE TABLE privileges.";
+                readonly disabledReadOnly: "Your role is read-only — Adminium never writes to this database. Choose a separate database for Adminium’s own tables.";
+                readonly disabledNoDdl: "This role cannot run DDL — Adminium migrations need CREATE TABLE. Choose a separate database for Adminium’s own tables.";
+                readonly disabledFile: "A schema file has no live database — choose a separate database for Adminium’s own tables.";
+            };
+            readonly separate: {
+                readonly title: "Separate database";
+                readonly description: "Adminium keeps its tables in a different database. Your source stays untouched — required for read-only sources.";
+                readonly dsn: "Meta database connection string";
+                readonly helper: "Needs write + DDL privileges — Adminium runs its own migrations there.";
+                readonly test: "Test connection";
+                readonly ok: "Compatible — write ✓ · DDL ✓";
+                readonly insufficient: "This role cannot host the meta store — Adminium needs write and CREATE TABLE privileges there.";
+                readonly errorTitle: "Meta store not compatible";
+            };
+            readonly testFailed: "Connection failed.";
+            readonly v1Note: {
+                readonly title: "About this install";
+                readonly body: "This server chose its meta store at first boot. This step validates that your choice is compatible with this connection and records it — the server enforces the same rule independently (409 META_PLACEMENT_INVALID). Moving an existing meta store is an ops task (M10).";
+            };
+        };
+        readonly intent: {
+            readonly title: "What do you need?";
+            readonly subtitle: "The intent shapes which pages get generated. You can change it later — changing it proposes a regeneration, never a silent rewrite.";
+            readonly trust: "We read your schema only — never your row data during setup.";
+            readonly fullAdmin: {
+                readonly title: "Full admin panel";
+                readonly description: "Dashboards, CRUD pages, search, imports and exports — everything your schema supports.";
+            };
+            readonly analytics: {
+                readonly title: "Read-only analytics";
+                readonly description: "Dashboards, charts and read-only grids. No forms, no writes — every role capped at Viewer.";
+            };
+            readonly crud: {
+                readonly title: "CRUD tables";
+                readonly description: "One editing page per table plus search and import/export — a minimal home, no dashboards.";
+            };
+            readonly support: {
+                readonly title: "Support console";
+                readonly description: "Queues, ticket and customer detail pages first. Deletes off by default. (Queue templates land in M7 — the v1 page set matches Full admin.)";
+            };
+        };
+        readonly generate: {
+            readonly title: "Generate your app";
+            readonly subtitle: "One page per included table plus dashboards per domain — intent:";
+            readonly run: "Generate dashboard";
+            readonly openApp: "Open your app";
+            readonly logLabel: "Generation log";
+            readonly log: {
+                readonly classifying: "Classifying schema…";
+                readonly composing: "Composing templates…";
+                readonly writing: "Writing pages…";
+                readonly done: "{pages} pages generated across {groups} nav groups";
+            };
+            readonly successTitle: "Your dashboard is ready";
+            readonly successBody: "{pages} pages across {groups} navigation groups — generated from your schema, editable in Studio.";
+            readonly errorTitle: "Generation failed";
+            readonly failed: "Generation failed — retry, or re-run introspection first.";
+            readonly fileTitle: "Schema file parsed — generation needs a live database";
+            readonly fileBody: "Your schema parsed cleanly and the preview above is real. Generating a running app straight from a schema file (with placeholder rows) is not available yet — connect a live database to generate today.";
+        };
+        readonly remap: {
+            readonly column: {
+                readonly nullable: "nullable";
+                readonly labelOverride: "Display label";
+                readonly labelHelper: "Inferred: {name}";
+                readonly logicalType: "Logical type";
+                readonly logicalTypeHelper: "Inferred: {type} (from {dbType}) — mapped by the adapter; not overridable in v1.";
+                readonly semantic: "Semantic type";
+                readonly unclassified: "Not classified yet.";
+                readonly semanticHelper: "Classifier: {tag} · {confidence}% confidence · source: {source}";
+                readonly semanticInferred: "inferred: {tag}";
+                readonly currency: "Currency";
+                readonly currencyHelper: "ISO 4217 code applied to money formatting.";
+                readonly pii: "Mask by default";
+                readonly piiHelper: "Masked values render redacted; unmasking requires the data.unmask_pii permission and is audit-logged.";
+                readonly enum: "Enum semantics";
+                readonly enumKind: "Enum kind";
+                readonly enumWorkflow: "Workflow";
+                readonly enumCategory: "Category";
+                readonly enumLabelFor: "Label for {value}";
+                readonly enumToneFor: "Tone for {value}";
+                readonly enumToneAuto: "auto";
+                readonly enumHelper: "Workflow enums drive status pills and board columns; tones map values onto the semantic tint scale.";
+            };
+            readonly diff: {
+                readonly one: "1 change";
+                readonly count: "{count} changes";
+                readonly saved: "Overrides saved.";
+                readonly revertOne: "Revert {change}";
+                readonly regenerate: "Regenerate pages";
+                readonly revertAll: "Revert all";
+                readonly save: "Save overrides";
+            };
+            readonly table: {
+                readonly iconPicker: "Table icon";
+                readonly system: "System";
+                readonly labelOverride: "Display label";
+                readonly labelHelper: "Inferred: {name}";
+                readonly icon: "Icon";
+                readonly navGroup: "Nav group";
+                readonly navGroupHelper: "Nav placement is decided by the generator — a table.navGroup override is not in the v1 vocabulary.";
+                readonly include: "Include in generated app";
+                readonly includeHelper: "Excluded tables get no pages and disappear from nav.";
+                readonly shape: "Table shape (classified)";
+                readonly role: "Role";
+                readonly unclassified: "Not classified";
+                readonly kind: "Kind";
+                readonly hierarchy: "Hierarchy";
+                readonly selfFk: "Self-reference via {column}";
+                readonly polymorphic: "Polymorphic pairs";
+                readonly rows: "Row estimate";
+                readonly shapeHelper: "Classification is recomputed on every introspection; overrides layer on top and survive regeneration.";
+            };
+            readonly relations: {
+                readonly declared: "Declared foreign keys";
+                readonly noneDeclared: "No declared foreign keys touch this table.";
+                readonly inferred: "Inferred relations";
+                readonly noneInferred: "Nothing inferred for this table.";
+                readonly confidence: "inferred · {pct}%";
+                readonly accepted: "Accepted";
+                readonly suppressed: "Suppressed";
+                readonly accept: "Accept";
+                readonly suppress: "Suppress";
+                readonly overrides: "Override relations (applied)";
+                readonly overrideBadge: "override";
+                readonly add: "Add virtual relation";
+                readonly fromColumn: "From column";
+                readonly noColumns: "No matching column";
+                readonly fromPlaceholder: "customer_id";
+                readonly toTable: "To table";
+                readonly noTables: "No matching table";
+                readonly toColumn: "To column";
+                readonly cardinality: "Cardinality";
+                readonly addButton: "Add relation";
+            };
+            readonly toast: {
+                readonly saved: "Schema overrides saved";
+                readonly savedDetail: "The applied schema below reflects your changes.";
+                readonly regenerated: "{created} created · {updated} updated · {unchanged} unchanged";
+                readonly regeneratedDetail: "Pages you edited by hand are preserved — only pages with an untouched generated_hash were regenerated in place.";
+                readonly regenerateFailed: "Regeneration failed";
+            };
+            readonly title: "Schema remap";
+            readonly subtitle: "{tables} tables · {applied} overrides applied";
+            readonly saveFailed: "Save failed: {message}";
+            readonly loadFailed: "Could not load the schema for this connection.";
+            readonly inspector: "Inspector";
+            readonly empty: {
+                readonly title: "Pick a table or column";
+                readonly description: "Select something in the schema tree to remap its label, type, relations or masking.";
+            };
+            readonly tabs: {
+                readonly details: "Details";
+                readonly relations: "Relations";
+            };
+            readonly tree: {
+                readonly label: "Schema";
+                readonly search: "Search tables and columns";
+                readonly searchPlaceholder: "Search tables…";
+                readonly noMatches: "No tables match your search.";
+                readonly collapse: "Collapse table";
+                readonly expand: "Expand table";
+                readonly unsaved: "Unsaved change";
+                readonly excluded: "Excluded";
+            };
+            readonly badge: {
+                readonly pk: "PK";
+                readonly fk: "FK";
+                readonly unique: "UNIQUE";
+                readonly pii: "PII";
+                readonly masked: "Masked";
+            };
+        };
+    };
+    readonly onboarding: {
+        readonly title: "Getting started";
+        readonly subtitle: "A few steps to get your workspace ready.";
+        readonly loading: "Loading your setup checklist…";
+        readonly welcome: "Welcome to Adminium, {name} 👋";
+        readonly progressBody: "You’ve completed {done} of {total} setup steps. Finish the rest to unlock the full workspace.";
+        readonly completeBody: "You’re all set — your workspace is fully configured.";
+        readonly ringLabel: "{done} of {total} steps complete";
+        readonly done: "Done";
+        readonly skip: "Skip for now";
+        readonly goToWorkspace: "Go to workspace";
+        readonly help: {
+            readonly title: "Need a hand?";
+            readonly body: "We’re here to help you get set up fast.";
+        };
+        readonly steps: {
+            readonly connectDatabase: {
+                readonly title: "Connect a database";
+                readonly desc: "Point Adminium at your Postgres, MySQL or SQLite — a read-only role is welcome.";
+                readonly time: "5 min";
+                readonly action: "Connect";
+            };
+            readonly chooseTables: {
+                readonly title: "Choose your tables";
+                readonly desc: "Pick which tables become pages — PII is masked by default.";
+                readonly time: "2 min";
+                readonly action: "Choose";
+            };
+            readonly inviteTeammates: {
+                readonly title: "Invite teammates";
+                readonly desc: "Bring your team in to explore and collaborate.";
+                readonly time: "2 min";
+                readonly action: "Invite";
+            };
+            readonly workspaceDefaults: {
+                readonly title: "Set workspace defaults";
+                readonly desc: "Theme, accent, density and language everyone starts with.";
+                readonly time: "1 min";
+                readonly action: "Set defaults";
+            };
+        };
+        readonly entry: {
+            readonly wayBack: "Getting started · {done}/{total}";
+            readonly dismiss: "Dismiss setup checklist";
+            readonly continue: "Continue setup";
+            readonly banner: "Finish setting up your workspace — {done} of {total} steps done.";
+        };
+    };
+    readonly views: {
+        readonly baseView: "All records";
+        readonly menuLabel: "Saved views";
+        readonly saveAs: "Save current as view…";
+        readonly updateActive: "Update “{name}”";
+        readonly rename: "Rename…";
+        readonly setDefault: "Set as default";
+        readonly delete: "Delete…";
+        readonly saveTitle: "Save view";
+        readonly save: "Save view";
+        readonly renameTitle: "Rename view";
+        readonly saveName: "Save name";
+        readonly nameLabel: "View name";
+        readonly namePlaceholder: "e.g. Active this month";
+        readonly nameRequired: "Enter a name for this view.";
+        readonly saveFailed: "Could not save the view.";
+        readonly deleteTitle: "Delete view";
+        readonly deleteBody: "This removes the saved view. Your data is not affected.";
+        readonly deletePrompt: "Type the view name to confirm";
+        readonly deleteConfirm: "Delete view";
+        readonly savedToast: "View “{name}” saved.";
+        readonly updatedToast: "View “{name}” updated.";
+        readonly defaultToast: "“{name}” is now the default view.";
+        readonly deletedToast: "View “{name}” deleted.";
+    };
+    readonly builder: {
+        readonly view: "View";
+        readonly edit: "Edit";
+        readonly done: "Done";
+        readonly addWidget: "Add widget";
+        readonly saveLayout: "Save layout";
+        readonly saving: "Saving…";
+        readonly savedShort: "Saved";
+        readonly options: "Dashboard options";
+        readonly resetLayout: "Reset layout";
+        readonly resetTitle: "Reset to the shared layout?";
+        readonly resetBody: "This removes your personal changes and restores the dashboard everyone sees. Your data isn’t affected.";
+        readonly resetConfirm: "Reset layout";
+        readonly resetDone: "Layout reset to the shared default.";
+        readonly sharedNote: "You’re editing the shared dashboard everyone sees.";
+        readonly personalNote: "You’re editing your personal layout — only you see these changes.";
+        readonly savedShared: "Dashboard saved for everyone with access.";
+        readonly empty: "This dashboard has no widgets yet.";
+        readonly emptyAction: "Add a widget";
+        readonly palette: {
+            readonly title: "Add a widget";
+            readonly count: "{count} widgets";
+            readonly searchLabel: "Search widgets";
+            readonly searchPlaceholder: "Search widgets…";
+            readonly clear: "Clear search";
+            readonly noResults: "No widgets match “{query}”.";
+            readonly add: "Add {name}";
+            readonly added: "{name} added.";
+        };
+        readonly inspector: {
+            readonly title: "Configure widget";
+            readonly empty: "This widget has no options to configure.";
+            readonly locked: "Locked";
+            readonly lockedHint: "This field is set by the source and can’t be edited here.";
+            readonly selectPlaceholder: "Select…";
+            readonly increment: "Increase";
+            readonly decrement: "Decrease";
+            readonly done: "Done";
+        };
+        readonly item: {
+            readonly configure: "Configure {name}";
+            readonly duplicate: "Duplicate {name}";
+            readonly remove: "Remove {name}";
+            readonly removed: "{name} removed.";
+            readonly duplicated: "{name} duplicated.";
+        };
+        readonly families: {
+            readonly kpi: "KPIs";
+            readonly charts: "Charts";
+            readonly tables: "Tables";
+            readonly feeds: "Feeds";
+            readonly calendar: "Calendar";
+            readonly boards: "Boards";
+            readonly geo: "Maps";
+            readonly media: "Media";
+            readonly communication: "Communication";
+            readonly forms: "Forms";
+            readonly chrome: "Navigation";
+            readonly system: "System";
+            readonly domain: "Domain";
+        };
+        readonly versions: "Versions";
+        readonly versionsEmpty: "No saved versions yet";
+        readonly saveAsVersion: "Save as version";
+        readonly saveVersionTitle: "Save a version";
+        readonly saveVersionBody: "Snapshots the current document. Restore it any time from Versions.";
+        readonly versionName: "Version name";
+        readonly versionNamePlaceholder: "e.g. Before Q3 rates change";
+    };
+    readonly setup: {
+        readonly title: "Set up Adminium";
+        readonly subtitle: "Create the first administrator. This happens once.";
+        readonly progress: "Setup progress";
+        readonly steps: {
+            readonly account: "Admin account";
+            readonly consent: "Privacy";
+        };
+        readonly account: {
+            readonly name: "Your name";
+            readonly email: "Email";
+            readonly emailInvalid: "Enter a valid email address.";
+            readonly password: "Password";
+            readonly passwordHelper: "At least {min} characters.";
+            readonly passwordTooShort: "Use at least {min} characters.";
+            readonly confirm: "Confirm password";
+            readonly passwordMismatch: "Passwords do not match.";
+            readonly continue: "Continue";
+            readonly strength: "Password strength";
+            readonly strengthLevels: {
+                readonly weak: "Weak";
+                readonly fair: "Fair";
+                readonly good: "Good";
+                readonly strong: "Strong";
+            };
+        };
+        readonly consent: {
+            readonly telemetry: {
+                readonly title: "Share anonymous usage data";
+                readonly description: "Helps us see which database engines to prioritize. Off unless you turn it on.";
+            };
+            readonly updates: {
+                readonly title: "Check for new releases";
+                readonly description: "Shows a notice when a new version — including a security fix — is available. This asks GitHub for the latest release, which reveals this instance’s IP address and version to GitHub. Nothing else is sent.";
+            };
+            readonly sentTitle: "Exactly what is sent:";
+            readonly sent: {
+                readonly instanceId: "A random instance ID (a UUID generated here; not derived from your name, host, or database)";
+                readonly version: "The Adminium version this instance runs";
+                readonly engines: "Which database engine types are connected (e.g. \"postgres\") — types only";
+            };
+            readonly neverTitle: "Never sent:";
+            readonly never: {
+                readonly schema: "Your schema — no table, column, or enum names";
+                readonly rows: "Your data — not a single row, ever";
+                readonly connections: "Connection strings, hostnames, or credentials";
+                readonly people: "User emails, names, or IDs";
+                readonly llm: "AI prompts or run contents";
+            };
+            readonly reversible: "Both are off by default and you can change either one later in Settings.";
+            readonly back: "Back";
+            readonly finish: "Create admin account";
+        };
+        readonly error: {
+            readonly alreadyCompleted: "This instance has already been set up. Sign in with the existing admin account.";
+            readonly rejected: "The server rejected those details. Check the email and password and try again.";
+            readonly failed: "Setup failed. Check your connection and try again.";
+        };
+    };
+    readonly about: {
+        readonly title: "About Adminium";
+        readonly subtitle: "Version, licence, and where this instance’s source code lives.";
+        readonly version: "Version";
+        readonly license: "Licence";
+        readonly metaStore: "Meta store";
+        readonly node: "Node.js";
+        readonly engine: {
+            readonly postgres: "PostgreSQL";
+            readonly mysql: "MySQL / MariaDB";
+            readonly sqlite: "SQLite";
+        };
+        readonly licenseCard: {
+            readonly title: "Free and open source";
+            readonly body: "Adminium is licensed under the GNU Affero General Public License v3.0. You are free to run, study, modify, and share it. If you offer a modified version to others over a network, the AGPL asks you to offer them its source code too.";
+        };
+        readonly viewLicense: "Read the licence";
+        readonly viewSource: "Get the source code";
+        readonly updates: {
+            readonly title: "Updates";
+            readonly description: "Whether this instance checks for new releases.";
+        };
+        readonly update: {
+            readonly disabled: "Update checks are off, so this instance never contacts GitHub. Turn them on in Settings to hear about new releases.";
+            readonly current: "You are on the latest release.";
+            readonly available: "Adminium {version} is available";
+            readonly availableBody: "You are running {version}.";
+            readonly viewRelease: "View release notes";
+        };
+        readonly desktop: {
+            readonly unknown: "Unknown";
+            readonly appVersion: "App version";
+            readonly serverVersion: "Server version";
+            readonly migration: "Meta-store migration";
+            readonly electron: "Electron";
+            readonly chromium: "Chromium";
+            readonly runtimeNode: "Node runtime";
+            readonly system: {
+                readonly title: "System";
+            };
+            readonly dataDir: "Data directory";
+            readonly reveal: "Show in folder";
+            readonly secret: {
+                readonly title: "Secret storage";
+                readonly safe: "Encrypted by your operating system";
+                readonly plainWarning: "This computer has no system keychain available, so your Adminium secret is stored unencrypted on disk. Anyone who can read this machine’s files can read it. Set up a login keychain (or a Linux secret service) and restart Adminium to protect it.";
+            };
+            readonly updates: {
+                readonly title: "Updates";
+                readonly mode: {
+                    readonly notify: "Notify me about new versions";
+                    readonly manual: "Only when I check";
+                    readonly disabled: "Off (air-gapped)";
+                };
+                readonly disabledBody: "Automatic updates are off (air-gapped). Install new versions manually.";
+                readonly check: "Check for updates";
+                readonly checking: "Checking…";
+                readonly lastChecked: "Last checked {when}";
+                readonly available: "Version {version} is available";
+                readonly none: "You are on the latest version.";
+                readonly unavailable: "Updates are turned off in this installation.";
+                readonly error: "Could not check for updates.";
+                readonly download: "Download update";
+                readonly downloading: "Downloading… {percent}%";
+                readonly downloaded: "Version {version} is ready to install";
+                readonly restart: "Restart to install";
+                readonly downloadError: "The download did not finish. You can try again.";
+                readonly toast: {
+                    readonly available: "A new version of Adminium is available";
+                    readonly view: "View";
+                    readonly downloaded: "Update ready to install";
+                    readonly restart: "Restart now";
+                };
+            };
+            readonly legal: {
+                readonly title: "Licences";
+                readonly agpl: "Adminium Desktop is free software under the GNU Affero General Public License v3.0.";
+                readonly viewLicense: "View licence";
+                readonly licenseTitle: "GNU Affero General Public License v3.0";
+                readonly licenseUnavailable: "The bundled licence file is not available in this build.";
+                readonly viewNotices: "Third-party licences";
+                readonly noticesTitle: "Third-party notices";
+                readonly noticesUnavailable: "Third-party notices are generated when the app is packaged and are not available in this build.";
+                readonly source: "Source code";
+                readonly close: "Close";
+            };
+            readonly telemetry: {
+                readonly title: "Anonymous usage data";
+                readonly label: "Share anonymous usage data";
+                readonly description: "Helps us decide which database engines to prioritise. Off unless you turn it on; no schema, data, or personal information is ever sent.";
+                readonly saveFailed: "Could not save that setting. Try again.";
+            };
+            readonly diagnostics: {
+                readonly title: "Diagnostics";
+                readonly description: "Details that help when you report a problem. No schema or data is included.";
+                readonly copy: "Copy diagnostic info";
+                readonly copied: "Copied";
+                readonly showLogs: "Show logs";
+                readonly dataSize: "Data size: {size}";
+            };
+        };
+    };
+    readonly apiKeys: {
+        readonly title: "API keys & tokens";
+        readonly subtitle: "Manage programmatic access to your workspace.";
+        readonly createButton: "Create key";
+        readonly copy: "Copy";
+        readonly copied: "Copied";
+        readonly revoke: "Revoke key";
+        readonly neverUsed: "Never used";
+        readonly lastUsed: "Last used {since}";
+        readonly scopesOverflow: "+{count} more";
+        readonly status: {
+            readonly active: "Active";
+            readonly revoked: "Revoked";
+            readonly expired: "Expired";
+        };
+        readonly list: {
+            readonly title: "Keys";
+            readonly activeCount: "{count, plural, one {# active key} other {# active keys}}";
+        };
+        readonly empty: {
+            readonly title: "No API keys yet";
+            readonly body: "Create one to call the Adminium API from your own code.";
+        };
+        readonly revealed: {
+            readonly title: "New key created";
+            readonly body: "Copy it now — you won’t be able to see it again.";
+        };
+        readonly rolesUnavailable: {
+            readonly title: "Roles are not visible to you";
+            readonly body: "Creating a key means choosing the role it acts as, and your account cannot read the role list. Ask an administrator for the “Manage roles” permission.";
+        };
+        readonly quickStart: {
+            readonly title: "Quick start";
+            readonly body: "Authenticate requests with your key in the Authorization header.";
+        };
+        readonly create: {
+            readonly title: "Create API key";
+            readonly description: "The key acts with the permissions of the role you pick.";
+            readonly name: "Name";
+            readonly namePlaceholder: "e.g. Analytics pipeline";
+            readonly role: "Role";
+            readonly roleHelper: "Pick the least-privileged role that can do the job.";
+            readonly expires: "Expires";
+            readonly expiresHelper: "Leave empty for a key that never expires.";
+            readonly submit: "Create key";
+            readonly failed: "Could not create the key";
+        };
+        readonly revokeConfirm: {
+            readonly title: "Revoke API key";
+            readonly body: "Any code still calling the API with “{name}” starts failing immediately. This cannot be undone.";
+            readonly prompt: "Type “{name}” to confirm";
+            readonly confirm: "Revoke key";
+        };
+    };
+    readonly changelog: {
+        readonly title: "Changelog";
+        readonly subtitle: "Product updates & releases.";
+        readonly allReleases: "All releases";
+        readonly tag: {
+            readonly new: "New";
+            readonly improved: "Improved";
+            readonly fixed: "Fixed";
+            readonly security: "Security";
+        };
+        readonly filter: {
+            readonly all: "All";
+            readonly label: "Filter changes by type";
+        };
+        readonly empty: {
+            readonly title: "Nothing under this filter";
+            readonly body: "No release has carried a change of this kind yet.";
+            readonly clear: "Show all changes";
+        };
+    };
+    readonly kb: {
+        readonly title: "Knowledge Base";
+        readonly subtitle: "{count, plural, one {# guide} other {# guides}} · full docs at docs.adminium.dev";
+        readonly openDocs: "Open the docs";
+        readonly browse: "Browse by topic";
+        readonly hero: {
+            readonly title: "How can we help?";
+            readonly subtitle: "Search guides, API docs and troubleshooting.";
+            readonly placeholder: "Search the knowledge base…";
+            readonly label: "Search the knowledge base";
+            readonly clear: "Clear search";
+        };
+        readonly category: {
+            readonly start: "Getting started";
+            readonly connect: "Connecting data";
+            readonly api: "API & developers";
+            readonly security: "Security & access";
+            readonly selfhost: "Self-hosting";
+            readonly trouble: "Troubleshooting";
+            readonly count: "{count, plural, one {# article} other {# articles}}";
+            readonly selected: "Filtering";
+        };
+        readonly list: {
+            readonly all: "All guides";
+            readonly clear: "Clear filter";
+        };
+        readonly empty: {
+            readonly title: "No guides match your search";
+            readonly body: "Try a different word, or search the full documentation at docs.adminium.dev.";
+            readonly openDocs: "Open the docs";
+        };
+        readonly article: {
+            readonly install: {
+                readonly title: "Install Adminium";
+                readonly excerpt: "Run from a source checkout or with docker run, and reach the first-run wizard in a minute.";
+            };
+            readonly firstAdmin: {
+                readonly title: "Create your first super admin";
+                readonly excerpt: "What the first-run wizard asks for, and why it can only run once.";
+            };
+            readonly connectDb: {
+                readonly title: "Connecting your first database";
+                readonly excerpt: "Point Adminium at PostgreSQL, MySQL or SQLite and generate an admin app.";
+            };
+            readonly schemaFile: {
+                readonly title: "Generate from a schema file";
+                readonly excerpt: "Upload a Prisma schema, a Django models.py, a Rails schema.rb or a .sql dump — no connection needed.";
+            };
+            readonly readOnly: {
+                readonly title: "Use a read-only role";
+                readonly excerpt: "Introspection reads schema metadata only. Give Adminium the least privilege it needs.";
+            };
+            readonly apiKeys: {
+                readonly title: "Authenticating with API keys";
+                readonly excerpt: "Create and revoke keys, and why a key is only ever shown to you once.";
+            };
+            readonly rest: {
+                readonly title: "REST API reference";
+                readonly excerpt: "Every endpoint the generated app exposes, with request and response shapes.";
+            };
+            readonly manifest: {
+                readonly title: "The page manifest";
+                readonly excerpt: "How a page is described as config, and how to hand-edit one.";
+            };
+            readonly roles: {
+                readonly title: "Roles & permissions";
+                readonly excerpt: "Assign Viewer, Editor and Admin, and build your own roles from the permission matrix.";
+            };
+            readonly audit: {
+                readonly title: "Reading the audit log";
+                readonly excerpt: "Who changed what, when, and from where.";
+            };
+            readonly secrets: {
+                readonly title: "How Adminium stores your secrets";
+                readonly excerpt: "Connection credentials are encrypted at rest with ADMINIUM_SECRET. API keys are hashed.";
+            };
+            readonly docker: {
+                readonly title: "Self-host with Docker";
+                readonly excerpt: "The official image, docker-compose, and running a separate meta database.";
+            };
+            readonly backup: {
+                readonly title: "Back up and move an instance";
+                readonly excerpt: "export-zip bundles your server config; import it to replay the same setup elsewhere.";
+            };
+            readonly telemetry: {
+                readonly title: "Telemetry and update checks";
+                readonly excerpt: "Both are opt-in and off by default. What is sent if you turn them on.";
+            };
+            readonly connectionFails: {
+                readonly title: "A database connection fails";
+                readonly excerpt: "Read the diagnostics card: host, port, TLS, and the IP your database must allow.";
+            };
+            readonly missingTables: {
+                readonly title: "Tables are missing after introspection";
+                readonly excerpt: "Schema visibility, excluded tables, and re-running generation.";
+            };
+        };
+    };
+    readonly desktop: {
+        readonly menu: {
+            readonly file: "File";
+            readonly fileNewDatabase: "New local database…";
+            readonly fileOpenSqlite: "Open SQLite file…";
+            readonly fileBackupNow: "Back up now…";
+            readonly fileRestore: "Restore from backup…";
+            readonly edit: "Edit";
+            readonly view: "View";
+            readonly window: "Window";
+            readonly help: "Help";
+            readonly helpDocs: "Adminium Docs";
+            readonly helpShortcuts: "Keyboard Shortcuts";
+            readonly helpLogs: "Show Logs";
+            readonly helpCheckForUpdates: "Check for Updates…";
+            readonly helpAbout: "About Adminium";
+        };
+        readonly settings: {
+            readonly explainer: "These settings apply to the Adminium app on this computer only. They are stored on this machine, not in your workspace.";
+        };
+        readonly security: {
+            readonly heading: "Sign-in";
+        };
+        readonly requireLogin: {
+            readonly label: "Require login on this device";
+            readonly description: "Adminium normally signs you in automatically on this computer. Turn this on to ask for your password at every launch — worth it if other people can use this machine. It takes effect the next time you open Adminium.";
+            readonly savedOn: "Login required on the next launch";
+            readonly savedOff: "Adminium will skip the login on this computer";
+            readonly saveFailed: "Could not save that setting. Try again.";
+        };
+        readonly chip: {
+            readonly local: "Local";
+            readonly lanShare: "Local · Sharing on LAN";
+            readonly remoteDb: "Local + remote DB";
+            readonly remoteDbOffline: "Remote DB offline";
+            readonly remoteDbOfflineDetail: "Can't reach {names}. Pages for those connections show a reconnect state.";
+        };
+        readonly lan: {
+            readonly heading: "Share on local network";
+            readonly label: "Let other devices on this network use Adminium";
+            readonly description: "Other computers, tablets and phones on the same network can open Adminium in a browser and sign in with their own account. Adminium has to stay open on this computer for them to reach it.";
+            readonly savedOn: "Sharing on your local network";
+            readonly savedOff: "Sharing stopped — Adminium is back to this computer only";
+            readonly saveFailed: "Could not change network sharing";
+            readonly noUsers: "You're the only person with an account, so nobody else can sign in yet. Sharing still works — you'll just need to invite people before they can use it.";
+            readonly usersUnknown: "Adminium couldn't check who else has an account on this computer. Sharing still works, and anyone with an account can sign in — this check is the only thing that failed.";
+            readonly acknowledge: "I understand — I'll invite people next";
+            readonly port: "Port";
+            readonly portHelper: "Default {port}";
+            readonly portInvalid: "Use a number between 1024 and 65535.";
+            readonly applyPort: "Change port";
+            readonly portInUse: "Port {port} is already in use by another program.";
+            readonly portInUseHint: "Nothing was changed — sharing is still off.";
+            readonly portInUseNoSuggestion: "Nothing was changed. Try a different port.";
+            readonly tryPort: "Try {port}";
+            readonly urlsHeading: "Open this on another device";
+            readonly noUrls: "This computer isn't connected to a network right now, so there's no address to share. Connect to Wi-Fi or plug in a cable and this list will fill in.";
+            readonly copyUrl: "Copy";
+            readonly sessions: "{count, plural, =0 {No devices signed in from this network} one {# device signed in from this network} other {# devices signed in from this network}}";
+            readonly sessionsUnknown: "Checking who is connected…";
+            readonly pending: "Starting to share…";
+            readonly mismatch: "Adminium is still reachable on this network";
+            readonly mismatchBody: "Sharing is switched off, but the server has not released the network yet. Restart Adminium to close it.";
+            readonly transportTitle: "Traffic on your local network is not encrypted.";
+            readonly transportBody: "Share only on networks you trust. For remote access, use Adminium self-host behind HTTPS.";
+            readonly firewall: "The first time you share, your operating system will ask whether to allow incoming connections — choose Allow, or other devices will not be able to reach Adminium.";
+        };
+        readonly setup: {
+            readonly title: "Welcome to Adminium";
+            readonly subtitle: "Four short steps and Adminium will have built an admin app from your database. Everything stays on this computer.";
+            readonly progress: "Setup progress";
+            readonly back: "Back";
+            readonly continue: "Continue";
+            readonly createAccount: "Create account and continue";
+            readonly step: {
+                readonly location: "Welcome";
+                readonly database: "Your first database";
+                readonly account: "Your account";
+                readonly generate: "Generate";
+            };
+            readonly dataDir: {
+                readonly heading: "Where should Adminium keep your data?";
+                readonly description: "Your databases, settings and backups all live in this folder. Everything stays on this computer — nothing is uploaded anywhere.";
+                readonly label: "Data folder";
+                readonly loading: "Reading the current location…";
+                readonly pending: "Adminium restarts when you continue, so it can move to this folder.";
+                readonly change: "Change…";
+                readonly revert: "Undo";
+                readonly dialogTitle: "Choose where Adminium keeps your data";
+                readonly cloudSyncTitle: "This folder is synced to the cloud";
+                readonly cloudSyncWarning: "Adminium stores its data in SQLite files. {provider} syncs files in “{folder}” by copying them in the background, which can corrupt a database that is open — losing data with no warning. Pick a folder outside {provider}.";
+                readonly chooseAnother: "Choose another folder";
+                readonly useAnyway: "Use it anyway — I accept the risk";
+                readonly unusableTitle: "Adminium cannot use that folder";
+                readonly failed: "Adminium could not use that folder.";
+            };
+            readonly source: {
+                readonly heading: "What should Adminium build from?";
+                readonly description: "Adminium reads a database’s schema and generates an admin app from it. You can add more databases later.";
+                readonly groupLabel: "Database source";
+                readonly local: {
+                    readonly title: "Create a new local database";
+                    readonly description: "Start from nothing, or from a schema file you already have. The database is created inside your data folder.";
+                    readonly name: "Database name";
+                    readonly namePlaceholder: "Operations";
+                    readonly nameUnusable: "Use at least one letter or number — the file name is built from this.";
+                    readonly fileHelper: "Creates {file}";
+                    readonly schemaLabel: "Start from";
+                    readonly blank: "Blank";
+                    readonly fromFile: "A schema file";
+                    readonly schemaFile: "Schema file";
+                    readonly schemaFileHelper: ".sql, pg_dump, Prisma, Drizzle, TypeORM, Sequelize, schema.rb, Django or Adminium JSON. Adminium translates it to SQLite.";
+                    readonly placeholder: "Auto-generate placeholder entries";
+                    readonly placeholderHelper: "You imported a schema with no rows. Seed each table with realistic sample data so your dashboards and charts render immediately.";
+                };
+                readonly openSqlite: {
+                    readonly title: "Open an existing SQLite file";
+                    readonly description: "Point Adminium at a .sqlite file on this computer. It is opened where it is — nothing is copied or moved.";
+                    readonly browse: "Choose a .sqlite file…";
+                    readonly change: "Choose a different file…";
+                    readonly networkTitle: "That file is on a network share";
+                    readonly networkBody: "SQLite locking is unreliable over network file shares, and a dropped connection mid-write can corrupt the database. A copy on this computer’s own disk is safer.";
+                };
+                readonly remote: {
+                    readonly title: "Connect to a server database";
+                    readonly description: "PostgreSQL or MySQL. Requires a reachable network database; Adminium’s own tables still stay on this computer.";
+                    readonly networkNote: "Requires a reachable network database";
+                    readonly metaNote: "Adminium’s own tables — your pages, settings and sign-in — stay in the data folder on this computer either way.";
+                    readonly engine: "Engine";
+                    readonly name: "Connection name";
+                    readonly namePlaceholder: "Production";
+                    readonly dsn: "Connection string";
+                    readonly dsnHelper: "Adminium tests this when it connects. Use a read-only role if you only want dashboards.";
+                };
+                readonly demo: {
+                    readonly title: "Explore the demo database";
+                    readonly description: "A ready-made team-operations database, so you can see what Adminium builds before pointing it at your own data. Delete it whenever you like.";
+                    readonly unavailable: "This build does not include the demo data, so there is nothing to load. Pick one of the options above.";
+                };
+            };
+            readonly account: {
+                readonly heading: "Create your account";
+                readonly description: "This is the administrator account for this copy of Adminium. The password protects your backups and anyone you share with on your network — you will not be asked for it at every launch.";
+                readonly name: "Your name";
+                readonly email: "Email";
+                readonly password: "Password";
+                readonly passwordHelper: "At least {min} characters.";
+                readonly confirm: "Confirm password";
+                readonly strength: "Password strength";
+                readonly strengthLevels: {
+                    readonly weak: "Weak";
+                    readonly fair: "Fair";
+                    readonly good: "Good";
+                    readonly strong: "Strong";
+                };
+                readonly singleUser: "Skip login on this computer";
+                readonly singleUserHelper: "Adminium signs you in automatically when you open it here. Turn this off if other people use this machine. You can change it later in Settings → Desktop.";
+                readonly locale: "Language";
+                readonly theme: "Appearance";
+                readonly alreadyExists: "This copy of Adminium already has an account. Sign in with it instead.";
+                readonly failed: "Adminium could not create that account.";
+            };
+            readonly generate: {
+                readonly creating: "Setting up your database…";
+                readonly introspecting: "Reading your schema — tables, columns and relationships…";
+                readonly working: "Working…";
+                readonly offlineNote: "All of this happens on this computer.";
+                readonly failedTitle: "Adminium could not set that database up";
+                readonly failedBody: "Something went wrong. Try again.";
+                readonly retry: "Try again";
+            };
+        };
+    };
+    readonly capabilities: {
+        readonly heading: "App permissions";
+        readonly description: "Apps you install can ask to use this computer’s hardware. You approve each one, and can revoke access anytime.";
+        readonly grantedTo: "Allowed for {app}";
+        readonly status: {
+            readonly available: "Available";
+            readonly stub: "Not available yet";
+            readonly unavailable: "Unavailable";
+        };
+        readonly allow: {
+            readonly action: "Allow…";
+        };
+        readonly revoke: {
+            readonly action: "Revoke";
+            readonly saved: "Access revoked";
+            readonly failed: "Could not revoke access. Try again.";
+        };
+        readonly grant: {
+            readonly saved: "Access allowed";
+            readonly failed: "Could not allow access. Try again.";
+        };
+        readonly catalog: {
+            readonly printerEscpos: {
+                readonly name: "Receipt printer (ESC/POS)";
+                readonly scope: "Print to receipt printers and open a connected cash drawer";
+            };
+        };
+        readonly consent: {
+            readonly title: "Allow {app}?";
+            readonly subtitle: "{app} is asking to use this computer’s hardware.";
+            readonly willAllow: "This will allow {app} to:";
+            readonly revokeNote: "You can revoke this at any time in Settings → Desktop. Only allow apps you trust.";
+            readonly deny: "Not now";
+            readonly approve: "Allow";
+        };
+    };
+    readonly emailTemplates: {
+        readonly title: "Email templates";
+        readonly subtitle: "Transactional and lifecycle emails your workspace sends.";
+        readonly search: "Search templates…";
+        readonly loadFailed: "Couldn’t load templates";
+        readonly empty: "No email templates yet";
+        readonly emptyBody: "Templates appear here once the server seeds or you create them.";
+        readonly noMatches: "No matching templates";
+        readonly noMatchesBody: "Try a different search.";
+        readonly live: "Live";
+        readonly disabled: "Disabled";
+        readonly name: "Template name";
+        readonly subject: "Subject";
+        readonly enabled: "Enabled";
+    };
+    readonly board: {
+        readonly addCard: "Add card";
+        readonly compose: {
+            readonly placeholder: "Card title…";
+            readonly add: "Add";
+            readonly cancel: "Cancel";
+        };
+        readonly empty: {
+            readonly title: "No board columns";
+            readonly body: "Add a status field to group cards into columns.";
+        };
+    };
+    readonly calendar: {
+        readonly dateRange: "Date range";
+        readonly compose: {
+            readonly placeholder: "Event title…";
+            readonly add: "Add";
+            readonly cancel: "Cancel";
+            readonly open: "Add event";
+        };
+        readonly agenda: {
+            readonly empty: "Nothing scheduled";
+        };
+    };
+    readonly scheduler: {
+        readonly prevWeek: "Previous week";
+        readonly nextWeek: "Next week";
+        readonly week: "Week";
+        readonly month: "Month";
+        readonly resource: "Resource";
+        readonly coverage: "Coverage";
+        readonly addShift: "Add shift";
+        readonly shiftCount: "{n} shifts";
+    };
+    readonly planning: {
+        readonly drawer: {
+            readonly close: "Close";
+            readonly loading: "Loading record";
+            readonly error: "Could not load this record.";
+        };
+    };
+    readonly files: {
+        readonly uploadsUnavailable: "Uploads are not available on this page yet.";
+    };
+    readonly chat: {
+        readonly messageSent: "Message sent";
+        readonly sendFailed: "The message could not be sent.";
+    };
+    readonly templates: {
+        readonly crud: {
+            readonly title: "Records";
+        };
+        readonly dashboard: {
+            readonly title: "Dashboard";
+        };
+        readonly board: {
+            readonly title: "Board";
+        };
+        readonly calendar: {
+            readonly title: "Calendar";
+        };
+        readonly scheduler: {
+            readonly title: "Scheduler";
+        };
+        readonly logViewer: {
+            readonly title: "Logs";
+        };
+        readonly files: {
+            readonly title: "Files";
+        };
+        readonly chat: {
+            readonly title: "Chat";
+        };
+        readonly builder: {
+            readonly title: "Builder";
+        };
+        readonly wizard: {
+            readonly title: "Wizard";
+        };
+        readonly settings: {
+            readonly title: "Settings";
+        };
+        readonly directory: {
+            readonly title: "Directory";
+            readonly searchPlaceholder: "Search people…";
+            readonly allFilter: "All";
+            readonly clearFilters: "Clear filters";
+            readonly detailTitle: "Person";
+            readonly emptyTitle: "No people yet";
+            readonly emptyBody: "People appear here as rows land in the table.";
+            readonly noMatchesTitle: "No matching people";
+            readonly noMatchesBody: "Try a different search or remove a filter.";
+            readonly errorTitle: "This directory failed to load";
+            readonly loading: "Loading people";
+            readonly memberCount: "{count} people";
+        };
+        readonly masterDetail: {
+            readonly title: "List & detail";
+            readonly allFilter: "All";
+            readonly clearFilters: "Clear filters";
+            readonly emptyTitle: "Nothing here yet";
+            readonly emptyBody: "Records appear here as rows land in the table.";
+            readonly noMatchesTitle: "No matching records";
+            readonly noMatchesBody: "Try removing a filter.";
+            readonly errorTitle: "This list failed to load";
+            readonly loading: "Loading records";
+            readonly selectPrompt: "Select a record";
+        };
+        readonly queueInbox: {
+            readonly title: "Queue";
+            readonly approve: "Approve";
+            readonly reject: "Reject";
+            readonly allSegment: "All";
+            readonly approvedToast: "{count} approved.";
+            readonly rejectedToast: "{count} rejected.";
+            readonly undoneToast: "Decision undone.";
+            readonly failedToast: "Decision failed.";
+            readonly bulkFailed: "{failed} of {total} selected rows could not be updated.";
+            readonly undoFailedToast: "Could not undo this decision.";
+            readonly rejectTitle: "Reject requests";
+            readonly rejectCount: "Selected · {count}";
+            readonly rejectNote: "The requester will be notified with your note.";
+            readonly rejectPlaceholder: "Add a note for the requester…";
+            readonly rejectConfirm: "Reject";
+            readonly emptyTitle: "Nothing in the queue";
+            readonly emptyBody: "New requests appear here as they arrive.";
+            readonly caughtUpTitle: "You’re all caught up";
+            readonly caughtUpBody: "No requests in this tab right now.";
+            readonly errorTitle: "This queue failed to load";
+            readonly loading: "Loading queue";
+            readonly selectPrompt: "Select a request";
+            readonly daysUnit: "{count} days";
+        };
+    };
+    readonly dataio: {
+        readonly back: "Back";
+        readonly import: {
+            readonly title: "Import data";
+            readonly stepUpload: "Upload";
+            readonly stepMap: "Map columns";
+            readonly stepValidate: "Validate";
+            readonly stepRun: "Import & review";
+            readonly targetLabel: "Target table";
+            readonly targetPlaceholder: "Choose a table page…";
+            readonly notATable: "That page is not a table — pick a table page to import into.";
+            readonly dropTitle: "Drop a CSV file to import";
+            readonly dropHint: "CSV up to 32 MB — the first row must be the header";
+            readonly skipTarget: "Don’t import";
+            readonly mapHint: "{count} data rows in {file} — choose a target for each column.";
+            readonly validating: "Validating…";
+            readonly toValidate: "Validate";
+            readonly validateFailed: "Validation failed.";
+            readonly validationSummary: "{valid} of {total} rows ready to import — {invalid} will be skipped.";
+            readonly allValid: "All rows passed validation";
+            readonly run: "Run import";
+            readonly runSkipping: "Import {valid} rows (skip {invalid})";
+            readonly progressLabel: "Import progress";
+            readonly running: "Importing…";
+            readonly kpiTotal: "Rows in file";
+            readonly kpiCreated: "Created";
+            readonly kpiUpdated: "Updated";
+            readonly kpiSkipped: "Skipped";
+            readonly inconsistent: "Import numbers are inconsistent — total must equal created + updated + skipped.";
+            readonly downloadErrors: "Download the skipped-rows report (CSV)";
+            readonly runFailed: "The import failed.";
+        };
+        readonly exports: {
+            readonly title: "Data exports";
+            readonly tableLabel: "Table";
+            readonly tablePlaceholder: "Choose a table…";
+            readonly notATable: "That page is not a table — pick a table page to export.";
+            readonly formatLabel: "Format";
+            readonly create: "Export";
+            readonly createFailed: "Could not request the export.";
+            readonly retention: "Exports are kept for 30 days, then expire.";
+            readonly statusProcessing: "Processing…";
+            readonly statusReady: "Ready — {rows} rows · click to download";
+            readonly statusFailed: "Failed — {error}";
+            readonly statusCancelled: "Cancelled";
+            readonly statusExpired: "Expired";
+            readonly emptyTitle: "No exports yet";
+            readonly emptyBody: "Request one above — artifacts appear here with their status.";
+        };
+    };
+    readonly reports: {
+        readonly title: "Scheduled reports";
+        readonly subtitle: "Recurring data snapshots of a page, delivered as in-app notifications.";
+        readonly new: "New report";
+        readonly loadFailed: "Could not load scheduled reports.";
+        readonly saveFailed: "Could not save this report.";
+        readonly nextRun: "Next run";
+        readonly emptyTitle: "No scheduled reports yet";
+        readonly emptyBody: "Create one to get a recurring data snapshot of any table page.";
+        readonly createTitle: "New scheduled report";
+        readonly editTitle: "Edit scheduled report";
+        readonly nameLabel: "Name";
+        readonly namePlaceholder: "e.g. Weekly revenue";
+        readonly pageLabel: "Page";
+        readonly pagePlaceholder: "Choose a page…";
+        readonly frequencyLabel: "Frequency";
+        readonly frequency: {
+            readonly daily: "Daily";
+            readonly weekly: "Weekly";
+            readonly monthly: "Monthly";
+        };
+        readonly dayOfWeekLabel: "Day";
+        readonly dayOfMonthLabel: "Day of month";
+        readonly timeLabel: "Time";
+        readonly timezoneLabel: "Timezone";
+        readonly formatLabel: "Delivery";
+        readonly formatHint: "Data snapshot (PDF/PNG rendering arrives in a later release) — each run produces a CSV snapshot and an in-app notification.";
+        readonly recipientsLabel: "Recipients";
+        readonly recipientsHint: "Stored with the report. Email delivery arrives in a later release — runs notify you in-app for now.";
+        readonly deliveryBadge: "CSV snapshot";
+        readonly delete: "Delete";
+        readonly create: "Create";
+        readonly cadence: {
+            readonly daily: "Daily at {time} ({zone})";
+            readonly weekly: "Weekly · {day} at {time} ({zone})";
+            readonly monthly: "Monthly · day {day} at {time} ({zone})";
+        };
+    };
+    readonly notifications: {
+        readonly channel: {
+            readonly inApp: "In-app";
+            readonly email: "Email";
+            readonly push: "Push";
+        };
+        readonly event: {
+            readonly reportReady: "Scheduled report ready";
+            readonly reportFailed: "Scheduled report failed";
+            readonly backupCompleted: "Backup completed";
+        };
+    };
+};
+export default _default;
+//# sourceMappingURL=common.d.ts.map