@powerportalspro/core 5.0.0-beta.3 → 5.0.0

package/dist/index.d.ts

@@ -1,12 +1,8 @@
 /**
- * URL builders for the framework's `/api/*` and UI endpoints. Mirrors the C# static
- * `Routes` class in `PowerPortalsPro.Web.Common` so the React side and the Blazor side
- * agree on URL shape without either codebase owning the templates.
- *
- * The C# version uses Pascal-cased property names (`Routes.Api.Auth.Login`); this
- * port uses camelCase per JS convention (`Routes.api.auth.login`). Path-segment
- * encoding matches the C# `Uri.EscapeDataString` calls verbatim — segments that the
- * C# leaves unencoded (table logical names, culture codes) are also unencoded here.
+ * URL builders for the framework's `/api/*` and UI endpoints. Path segments
+ * use `encodeURIComponent` where they're parameterised (record ids, view ids,
+ * table logical names that may contain user-supplied characters); known-safe
+ * segments (culture codes, fixed enum values) are unencoded.
  */
 /**
  * Static accessors for the framework's API and UI route groups. Mirrors the C#
@@ -28,14 +24,39 @@ declare const Routes: {
         readonly retrieveLocalizedStrings: "/api/localizedStrings/{culture}";
         /** Template — POST a batch of OrganizationRequest payloads. */
         readonly executeMultiple: "/api/executeMultiple";
-        /** GET — environment-wide file upload settings (blocked extensions, max upload size). */
-        readonly environmentFileSettings: "/api/environmentFileSettings";
+        /**
+         * GET — organization-wide settings sourced from the Dataverse `organization` record:
+         * default currency plus file-upload constraints (blocked extensions, max upload size).
+         * Replaces the legacy `/api/environmentFileSettings` endpoint.
+         */
+        readonly organizationSettings: "/api/organizationSettings";
         /** POST — clear all server-side caches. SystemAdmin-only. */
         readonly clearAllCaches: "/api/caches/clear";
         /** GET — every server-side cache name. SystemAdmin-only. */
         readonly cacheNames: "/api/caches";
         /** Template — POST to clear a single named cache. SystemAdmin-only. */
         readonly clearCache: "/api/caches/{cacheName}/clear";
+        /**
+         * GET — admin localization overview: configured sources plus the per-source
+         * load records produced by the most recent warmup. SystemAdmin-only. Backs
+         * the LocalizationAdmin component (Blazor-only today; React mirror TBD).
+         */
+        readonly localizationOverview: "/api/localizations/overview";
+        /**
+         * GET — JSON of the keys one source contributed to one culture during the most
+         * recent warmup. `sourceId` + `culture` are query-string parameters (a sourceId
+         * can contain colons/slashes, so they're not path segments). SystemAdmin-only.
+         */
+        readonly localizationSourceDownload: "/api/localizations/sources/download";
+        /**
+         * GET — JSON of every key the cache will serve for a culture (post-merge winning
+         * values across all sources). `culture` is a query-string parameter. SystemAdmin-only.
+         */
+        readonly localizationMergedDownload: "/api/localizations/merged/download";
+        /** GET — whether translation is configured, the managed solution is installed, and the candidate target languages. SystemAdmin-only. */
+        readonly localizationTranslationAvailability: "/api/localizations/translation/availability";
+        /** POST — translate an uploaded localization file into one or more target languages. SystemAdmin-only. */
+        readonly localizationTranslate: "/api/localizations/translation";
         /** Template — GET file metadata + (optionally) content for one record/column. */
         readonly retrieveFileInfo: "/api/files/{tableLogicalName}/{recordId}/{columnName}";
         /** Template — POST record ids; returns file info + content for many records of one column. */
@@ -71,10 +92,10 @@ declare const Routes: {
         readonly getRetrieveTableMetadataRoute: (tableLogicalName: string) => string;
         /**
          * Resolved URL for retrieving the current user's combined
-         * `TableSecurityPermission` mask for a single table. Mirrors the
-         * server-side `ITablePermissionCache.GetPermissionForUserAsync` lookup
-         * the Blazor grid buttons already use via DI — exposed so the React
-         * client can read the same answer without firing a grid query.
+         * `TableSecurityPermission` mask for a single table. Routes through
+         * the server-side `ITablePermissionCache.GetPermissionForUserAsync`
+         * lookup so the client can read the table-level answer without firing
+         * a grid query.
          * `GridDataResponse.tablePermissions` carries the same value when a
          * grid query happens to be in flight; this endpoint covers the other
          * cases (custom toolbars, conditional UI elsewhere on the page).
@@ -158,8 +179,8 @@ declare const Routes: {
             readonly confirmEmail: "/api/auth/confirm-email";
             /** POST — send a fresh confirmation email. */
             readonly resendEmailConfirmation: "/api/auth/resend-email-confirmation";
-            /** GET — list of configured external (OAuth) login providers. */
-            readonly externalProviders: "/api/auth/external-providers";
+            /** GET — anonymous auth options for the sign-in UI: the local-accounts flag plus the configured external (OAuth) providers. */
+            readonly options: "/api/auth/options";
             /** GET — kicks off the OAuth flow for the named external provider. Full-page navigate, do not fetch. */
             readonly externalLogin: "/api/auth/external-login";
             /** GET — snapshot the in-flight external-login cookie set by the OAuth callback. */
@@ -265,8 +286,8 @@ interface PowerPortalsProErrorInit {
 /**
  * Base error thrown by `Transport` for every non-2xx response. Subclasses
  * (`UnauthorizedAccessError`, `ArgumentError`, `ArgumentNullError`,
- * `InvalidOperationError`) are constructed when the server's `exceptionType`
- * extension matches a known CLR type, mirroring the in-process Blazor experience.
+ * `InvalidOperationError`) are constructed when the server's
+ * `exceptionType` extension matches a known CLR type.
  */
 declare class PowerPortalsProError extends Error {
     readonly status: number;
@@ -326,19 +347,19 @@ interface RequestOptions {
     headers?: Record<string, string>;
 }
 /**
- * Thin `fetch` wrapper that owns the cross-cutting concerns the C# `HttpClient`-based
- * `PowerPortalsProService` handles for Blazor:
+ * Thin `fetch` wrapper that owns the cross-cutting concerns of the typed
+ * client:
  *
- * 1. **Cookie auth.** Always sends `credentials: 'include'` so the ASP.NET Identity
- *    cookie reaches `/api/*`, mirroring the Blazor WASM `CookieCredentialsHandler`.
+ * 1. **Cookie auth.** Always sends `credentials: 'include'` so the ASP.NET
+ * Identity cookie reaches `/api/*`.
  * 2. **JSON in / out.** Serializes the body as JSON (when present) and parses the
- *    response as JSON. Sets the `Content-Type` and `Accept` headers accordingly.
+ * response as JSON. Sets the `Content-Type` and `Accept` headers accordingly.
  * 3. **Typed-error rehydration.** On non-2xx responses with `application/problem+json`,
- *    maps the body's `exceptionType` extension to the matching
- *    {@link PowerPortalsProError} subclass — `UnauthorizedAccessError`,
- *    `ArgumentError`, `ArgumentNullError`, `InvalidOperationError`, or the base type
- *    for unrecognized CLR exceptions. Non-problem-json failures throw the base type
- *    with the raw response text as the detail.
+ * maps the body's `exceptionType` extension to the matching
+ * {@link PowerPortalsProError} subclass — `UnauthorizedAccessError`,
+ * `ArgumentError`, `ArgumentNullError`, `InvalidOperationError`, or the base type
+ * for unrecognized CLR exceptions. Non-problem-json failures throw the base type
+ * with the raw response text as the detail.
  *
  * `Transport` is an implementation detail of the higher-level clients
  * (`AuthClient`, etc.) and is rarely consumed directly. It's exported so advanced
@@ -822,7 +843,7 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/environmentFileSettings": {
+    "/api/organizationSettings": {
         parameters: {
             query?: never;
             header?: never;
@@ -844,7 +865,7 @@ interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["EnvironmentFileSettings"];
+                        "application/json": components["schemas"]["OrganizationSettings"];
                     };
                 };
             };
@@ -1175,6 +1196,186 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/localizations/overview": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["LocalizationOverview"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/localizations/sources/download": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query: {
+                    sourceId: string;
+                    culture: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/localizations/merged/download": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query: {
+                    culture: string;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/localizations/translation/availability": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TranslationAvailability"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/localizations/translation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["TranslationRequest"];
+                };
+            };
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["TranslationResult"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/auth/external-login/remember-choice": {
         parameters: {
             query?: never;
@@ -1185,20 +1386,19 @@ interface paths {
         /**
          * Writes the chooser's "remember my choice" cookie for providerKey
          *          and redirects to returnUrl. A trampoline used by server-rendered
-         *          ExternalLogin pages — those run inside a Blazor circuit where the HTTP response
-         *          has already flushed by the time the user clicks the chooser button, so a direct
-         *          cookie write throws "Headers are read-only, response has already started." Hitting
-         *          this endpoint via a top-level navigation creates a fresh response where headers
-         *          are still writable. SPA flows skip this entirely — they write the cookie inline
-         *          in `/external-login/select`.
+         *          ExternalLogin pages — by the time the user clicks the chooser button the page's
+         *          HTTP response has already flushed, so a direct cookie write throws "Headers are
+         *          read-only, response has already started." Hitting this endpoint via a top-level
+         *          navigation creates a fresh response where headers are still writable. SPA flows
+         *          skip this entirely — they write the cookie inline in `/external-login/select`.
          *
          *          Anonymous on purpose: the cookie value is just a UI preference (per-provider-key
          *          pick), nothing security-sensitive. returnUrl is validated as a
          *          local URL to avoid open-redirect.
          *          `internal` so PowerPortalsProWebServer.UsePowerPortalsProWebServer
          *     can also wire it up — server-rendered hosts that don't call
-         *      still need this trampoline,
-         *     since their ExternalLogin Blazor page is the consumer of the redirect.
+         *     IEndpointRouteBuilder AuthEndpoints.MapAuthEndpoints&lt;TUser&gt;(WebApplication app) still need this trampoline,
+         *     since their server-rendered ExternalLogin page is the consumer of the redirect.
          */
         get: {
             parameters: {
@@ -1774,7 +1974,7 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/auth/external-providers": {
+    "/api/auth/options": {
         parameters: {
             query?: never;
             header?: never;
@@ -1796,7 +1996,7 @@ interface paths {
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/json": components["schemas"]["ExternalLoginProviderInfo"][];
+                        "application/json": components["schemas"]["AuthOptionsResponse"];
                     };
                 };
             };
@@ -2763,7 +2963,7 @@ interface components {
         AggregateType: 0 | 1 | 2 | 3 | 4 | 5 | 6;
         /**
          * @description Compression format for the archive produced by
-         *     <see cref="!:Services.IPowerPortalsProService.CreateFileArchiveAsync" />.
+         *     `IPowerPortalsProService.CreateFileArchiveAsync`.
          *     Currently only ArchiveFormat.Zip is supported; the enum is open-ended so
          *     future formats can land without breaking the wire schema.
          * @enum {integer}
@@ -2791,6 +2991,29 @@ interface components {
              */
             authenticatorUri?: string;
         };
+        /**
+         * @description Auth configuration the SPA needs before rendering the sign-in experience, returned by
+         *     `GET /api/auth/options`. Anonymous-safe — the login page calls it on first paint to
+         *     decide whether to show the local email/password form (plus the register / password-reset
+         *     links) and which external-provider buttons to render.
+         */
+        AuthOptionsResponse: {
+            /**
+             * @description `true` when the portal accepts local username/password accounts (registration,
+             *             password sign-in, and password reset). `false` for internal-only portals where
+             *             users authenticate exclusively through an external provider (Microsoft/Entra) — the
+             *             SPA hides the local form and the register / forgot-password affordances. Defaults to
+             *             `true` so hosts that don't configure it keep the full local-account experience.
+             */
+            localAccountsEnabled?: boolean;
+            /**
+             * @description The configured external (OAuth) login providers — the auth schemes the host registered
+             *     via `AddAuthentication().AddMicrosoftAccount()` / `.AddGoogle()` / etc., minus
+             *     the cookie / 2FA / Identity-internal schemes. Drives the login page's provider buttons
+             *     and the manage-external-logins "add a provider" list.
+             */
+            externalProviders?: components["schemas"]["ExternalLoginProviderInfo"][];
+        };
         /** @description One row of Task&lt;IReadOnlyList&lt;CacheClearResult&gt;&gt; ICacheManager.ClearAllAsync(CancellationToken cancellationToken = default(CancellationToken))'s report. */
         CacheClearResult: {
             /** @description Cache name (matches string IClearableCache.Name). */
@@ -2825,8 +3048,8 @@ interface components {
         };
         /**
          * @description Outcome of `POST /api/auth/manage/email/change`. Members carry explicit
-         *     integer values so non-Blazor consumers comparing against the JSON wire form
-         *     get a stable contract across reorderings.
+         *     integer values so the JSON wire form is a stable contract across
+         *     reorderings.
          * @enum {integer}
          */
         ChangeEmailResult: 0 | 1;
@@ -2854,8 +3077,8 @@ interface components {
         };
         /**
          * @description Outcome of `POST /api/auth/manage/password/change`. Members carry
-         *     explicit integer values so non-Blazor consumers comparing against the JSON
-         *     wire form get a stable contract across reorderings.
+         *     explicit integer values so the JSON wire form is a stable contract
+         *     across reorderings.
          * @enum {integer}
          */
         ChangePasswordResult: 0 | 1 | 2;
@@ -2892,7 +3115,7 @@ interface components {
          * @description Fully-shaped chart input: category labels plus one or more datasets.
          *     Returned by `POST /api/charts/data` and consumed by the
          *     `&lt;Chart&gt;` / `&lt;FluentUIChart&gt;` / `&lt;DataverseChart&gt;`
-         *     components on both the Blazor and React sides.
+         *     components.
          */
         ChartData: {
             /** @description Category labels rendered along the primary axis. */
@@ -2929,7 +3152,7 @@ interface components {
             /**
              * @description Result column name to read chart labels (X axis) from. Required
              *     for Guid? ChartDataRequest.ViewId and string? ChartDataRequest.FetchXml modes;
-             *     derived from <see cref="!:AggregateChartConfig.GroupByColumn" />
+             *     derived from ChartGrouping AggregateChartConfig.GroupBy
              *     when AggregateChartConfig? ChartDataRequest.Aggregate is set.
              */
             labelColumn?: null | string;
@@ -2944,8 +3167,8 @@ interface components {
              * @description Optional result column name used to split rows into multiple
              *     datasets. When set, rows sharing the same series value form one
              *     dataset. For AggregateChartConfig? ChartDataRequest.Aggregate mode, derived from
-             *     <see cref="!:AggregateChartConfig.SeriesColumn" /> or implied by
-             *     <see cref="!:AggregateChartConfig.SeriesDateGrouping" />.
+             *     ChartGrouping? AggregateChartConfig.Series or implied by its
+             *     ChartDateGrouping ChartGrouping.DateGrouping.
              */
             seriesColumn?: null | string;
             /**
@@ -3473,7 +3696,7 @@ interface components {
         };
         /**
          * @description A sort specification — a column to sort by and the direction. Shared
-         *     across the framework: the Blazor grid uses it for UI sort state,
+         *     across the framework: grid UIs use it for sort state,
          *     `IFetchXmlQueryComposer` uses it for FetchXML composition, and
          *     the `POST /api/grids/data` endpoint receives it as part of the
          *     GridDataRequest body. string ColumnSort.ColumnName may
@@ -3713,8 +3936,8 @@ interface components {
         };
         /**
          * @description Outcome of `POST /api/auth/external-login/confirm`. Members carry
-         *     explicit integer values so non-Blazor consumers comparing against the JSON
-         *     wire form get a stable contract across reorderings.
+         *     explicit integer values so the JSON wire form is a stable contract
+         *     across reorderings.
          * @enum {integer}
          */
         ConfirmExternalLoginResult: 0 | 1 | 2 | 3;
@@ -3760,6 +3983,52 @@ interface components {
                 [key: string]: components["schemas"]["ColumnValueBase"];
             };
         };
+        /**
+         * @description A Dataverse `transactioncurrency` record, denormalized for client consumption.
+         *     Populated server-side onto Currency? TableRecord.Currency whenever a record carries
+         *     at least one money column, so currency-aware editors (`MoneyEdit` et al.) can
+         *     render the correct symbol without a separate round-trip.
+         */
+        Currency: {
+            /**
+             * Format: uuid
+             * @description The `transactioncurrencyid` primary key. Matches the object? ColumnValueBase.Value
+             *     stored against the record's `transactioncurrencyid` column when present.
+             */
+            id: string;
+            /**
+             * @description The ISO 4217 three-letter code (e.g. `USD`, `EUR`, `JPY`). Read from
+             *     `isocurrencycode`. Useful for ARIA labels and culture-aware formatting fallbacks.
+             */
+            isoCode: string;
+            /**
+             * @description The display symbol Dataverse stores in `currencysymbol` — up to 5 characters,
+             *     typically a single Unicode glyph (`$`, `€`, `£`, `¥`) but
+             *     occasionally a short string for currencies that lack a single-glyph form
+             *     (`Fr`, `kr`, `R$`) or org-specific custom values. Rendered verbatim
+             *     in the editor — Unicode + font fallback covers every glyph; no SVG sidecar.
+             */
+            symbol: string;
+            /**
+             * @description The localized currency name from `currencyname` (e.g. `US Dollar`). Used
+             *     in pickers, tooltips, and accessibility text.
+             */
+            name: string;
+            /**
+             * Format: int32
+             * @description Decimal places to display, sourced from `currencyprecision`. Falls back to 2
+             *     when Dataverse leaves the field null. Independent of int MoneyMetadata.Precision,
+             *     which is the column-level precision; this is the currency-level default.
+             */
+            precision?: number | string;
+            /**
+             * Format: double
+             * @description Exchange rate against the org's base currency, from `exchangerate`. `1.0`
+             *     for the base currency itself. Surfaced primarily for diagnostic / advanced display
+             *     scenarios — editors don't perform conversion locally.
+             */
+            exchangeRate?: number | string;
+        };
         /**
          * @description Snapshot of the signed-in user's available sign-in paths, returned by
          *     `GET /api/auth/manage/login-info`. Combines the linked external logins
@@ -3903,7 +4172,7 @@ interface components {
             /**
              * @description The user's current password — required when the account has a local
              *     password set, ignored otherwise (external-login-only accounts). Surfacing
-             *     the requirement up-front via <see cref="!:DeletePersonalDataResponse.RequirePassword" />
+             *     the requirement up-front via DeletePersonalDataResult.RequireLocalPassword
              *     keeps the form UX correct without a separate "is password set" probe.
              */
             password?: null | string;
@@ -3920,8 +4189,8 @@ interface components {
         };
         /**
          * @description Outcome of `POST /api/auth/manage/personal-data/delete`. Members carry
-         *     explicit integer values so non-Blazor consumers comparing against the JSON
-         *     wire form get a stable contract across reorderings.
+         *     explicit integer values so the JSON wire form is a stable contract
+         *     across reorderings.
          * @enum {integer}
          */
         DeletePersonalDataResult: 0 | 1 | 2;
@@ -3944,28 +4213,6 @@ interface components {
             success?: boolean;
         };
         EntityRole: number;
-        /**
-         * @description Environment-wide file upload constraints pulled from the Dataverse `organization`
-         *     record. Clients use these to mirror server-side enforcement (blocked extensions,
-         *     upload size ceiling) so users get a friendly client-side rejection instead of a
-         *     round-trip failure.
-         */
-        EnvironmentFileSettings: {
-            /**
-             * @description Lowercase file extensions (without the leading dot) that Dataverse refuses to
-             *     accept as uploads — for example `"svg"`, `"exe"`, `"bat"`. Sourced
-             *     from the organization's `blockedattachments` setting (a semicolon-delimited
-             *     string in Dataverse, parsed and normalised here).
-             */
-            blockedExtensions: string[];
-            /**
-             * Format: int64
-             * @description Maximum upload size for file attachments and file-column payloads, in bytes.
-             *     Sourced from the organization's `maxuploadfilesize` setting. Dataverse stores
-             *     it as bytes; callers should compare directly against file byte length.
-             */
-            maxUploadFileSizeInBytes: number | string;
-        };
         /**
          * @description One option presented to the user when a single external sign-in matches
          *     both a Dataverse `systemuser` and a `contact`. Used by
@@ -3987,8 +4234,8 @@ interface components {
         };
         /**
          * @description Which Dataverse table backs an external-login candidate. Members carry
-         *     explicit integer values so non-Blazor consumers comparing against the JSON
-         *     wire form get a stable contract across reorderings.
+         *     explicit integer values so the JSON wire form is a stable contract
+         *     across reorderings.
          * @enum {integer}
          */
         ExternalLoginCandidateKind: 0 | 1;
@@ -4015,9 +4262,9 @@ interface components {
             providerDisplayName?: string;
         };
         /**
-         * @description Describes one configured external (OAuth) login provider, surfaced by
-         *     `GET /api/auth/external-providers` so SPAs can render provider buttons
-         *     without hardcoding the list.
+         * @description Describes one configured external (OAuth) login provider, surfaced via
+         *     `GET /api/auth/options` (IReadOnlyList&lt;ExternalLoginProviderInfo&gt; AuthOptionsResponse.ExternalProviders) so SPAs
+         *     can render provider buttons without hardcoding the list.
          */
         ExternalLoginProviderInfo: {
             /**
@@ -4038,8 +4285,9 @@ interface components {
          * @description Returned by `GET /api/auth/manage/external-logins`. Lists the external
          *     logins currently linked to the signed-in user.
          *
-         *     To render an "add a new external login" picker, the client should call
-         *     `GET /api/auth/external-providers` and subtract anything already in
+         *     To render an "add a new external login" picker, the client should read the providers
+         *     from `GET /api/auth/options` (IReadOnlyList&lt;ExternalLoginProviderInfo&gt; AuthOptionsResponse.ExternalProviders) and
+         *     subtract anything already in
          *     IReadOnlyList&lt;ExternalLoginInfo&gt; ExternalLoginsResponse.CurrentLogins. To decide whether unlinking a given external
          *     login would lock the user out (no local password AND only one external
          *     login linked), call `GET /api/auth/manage/login-info` for the
@@ -4101,26 +4349,34 @@ interface components {
         };
         /**
          * @description Body of `POST /api/grids/data`. Lets clients run a paged,
-         *     searchable, sortable query against either a stored Dataverse view
-         *     (Guid? GridDataRequest.ViewId) or a caller-supplied FetchXML
-         *     (string? GridDataRequest.FetchXml). Server composes the final FetchXML via the
+         *     searchable, sortable query against a stored Dataverse view
+         *     (Guid? GridDataRequest.ViewId), a caller-supplied FetchXML
+         *     (string? GridDataRequest.FetchXml), or both — in which case the FetchXML is the
+         *     query and the Guid? GridDataRequest.ViewId supplies the view-definition identity
+         *     used to resolve view-specific localized column titles. At least one of
+         *     the two must be supplied. Server composes the final FetchXML via the
          *     shared `IFetchXmlQueryComposer` so the search / sort / paging
-         *     semantics match the Blazor grid exactly.
+         *     semantics are consistent across every client of the endpoint.
          */
         GridDataRequest: {
             /**
              * Format: uuid
-             * @description Stored Dataverse view to use as the base query. Server loads the
-             *     view's FetchXML and column list from `IViewMetadataCache`.
-             *     Mutually exclusive with string? GridDataRequest.FetchXml; exactly one of the
-             *     two must be supplied.
+             * @description Stored Dataverse view to use as the base query. When supplied alone,
+             *     the server loads the view's FetchXML and column list from
+             *     `IViewMetadataCache`. When supplied alongside string? GridDataRequest.FetchXml,
+             *     the FetchXML drives the query and this id is used only as the
+             *     view-definition identity for view-specific localized column-title
+             *     resolution (`tables.{table}.views.{id}.columns.*`) — no savedquery
+             *     is loaded. At least one of Guid? GridDataRequest.ViewId / string? GridDataRequest.FetchXml
+             *     must be supplied.
              */
             viewId?: null | string;
             /**
              * @description Caller-supplied FetchXML used as the base query. Useful for
              *     custom (in-memory) views, dynamic queries assembled by consumer
-             *     code, or lookup-style minimal-fetch shapes. Mutually exclusive
-             *     with Guid? GridDataRequest.ViewId.
+             *     code, or lookup-style minimal-fetch shapes. May be combined with
+             *     Guid? GridDataRequest.ViewId (see its docs) to give an in-memory view a
+             *     stable identity for localization.
              */
             fetchXml?: null | string;
             /**
@@ -4167,7 +4423,7 @@ interface components {
              *                 `&lt;link-entity&gt;`). Filters, sorts, and link-entity
              *                 definitions on the base query are preserved.
              *                 Use case: consumer-declared &lt;GridColumn&gt; children on
-             *     the React / Blazor grid express the displayed column set
+             *     the grid component express the displayed column set
              *     authoritatively — this field forwards that intent down to the
              *     server so the resolved column list + fetched data line up with
              *     what the consumer asked to see, regardless of what the underlying
@@ -4233,9 +4489,9 @@ interface components {
              *     table scope (Create especially is table-scoped — it doesn't make sense
              *     per-row), so toolbar buttons can gate "New" / "Delete" off this one
              *     authoritative value instead of sampling the first row's mask as a
-             *     proxy. Computed via the same cached
-             *     `ITablePermissionCache.GetPermissionForUserAsync` the Blazor
-             *     grid buttons already use, so both stacks read the same answer.
+             *     proxy. Computed via the cached
+             *     `ITablePermissionCache.GetPermissionForUserAsync` so every
+             *     caller reads the same answer.
              */
             tablePermissions: components["schemas"]["TableSecurityPermission"];
             /** @description Paging metadata describing the current page and how to request the next one. */
@@ -4265,9 +4521,9 @@ interface components {
          *     to predict it (or fetch the parent metadata just to pick a filter shape).
          *     The wire payload is identical for both directionalities.
          *
-         *     Powers the React / Blazor `SubGrid` ("rows related to this parent")
-         *     and the React `ManyToManyLookupEdit`'s initial-selection load. For
-         *     the lookup edit's autocomplete pool ("records not currently related to
+         *     Powers the `SubGrid` component ("rows related to this parent")
+         *     and `ManyToManyLookupEdit`'s initial-selection load. For the
+         *     lookup edit's autocomplete pool ("records not currently related to
          *     this parent"), set RelationshipFilterMode RelationshipFilter.Mode to
          *     RelationshipFilterMode.ExcludeExistingRecords — that path
          *     is many-to-many only and the server rejects it for one-to-many
@@ -4305,9 +4561,9 @@ interface components {
         JoinOperator: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
         /**
          * @description Top-level manifest for the localization-bundle endpoints. Returned by
-         *                 <see cref="!:Routes.Localizations.Manifest" />; clients fetch this on
+         *                 string Localizations.Manifest; clients fetch this on
          *                 startup to discover supported locales, then issue a follow-up call to
-         *                 <see cref="!:Routes.Localizations.Thumbprints" /> for the resolved locale's
+         *                 string Localizations.Thumbprints for the resolved locale's
          *                 thumbprints.
          *                 Splitting "what locales exist" from "what thumbprints does locale X have"
          *     keeps the version response tiny (a handful of locale codes) regardless
@@ -4324,10 +4580,18 @@ interface components {
              *     culture first).
              */
             supportedLocales: string[];
+            /**
+             * @description The configured UrlCultureStrategy as a
+             *     string (`PathPrefix` / `PathPrefixAll` / `CookieOnly`). Lets a SPA
+             *     client match the server's URL convention: prefix-based strategies drive locale from
+             *     the URL and navigate on switch, while `CookieOnly` switches in place via the
+             *     culture cookie without touching the URL.
+             */
+            urlCultureStrategy: string;
         };
         /**
          * @description Per-locale thumbprint manifest. Returned by
-         *                 <see cref="!:Routes.Localizations.Thumbprints" /> for a single resolved
+         *                 string Localizations.Thumbprints for a single resolved
          *                 locale; carries the content-derived thumbprint for every downloadable
          *                 bundle a client could need at that locale.
          *                 Per-resource thumbprints mean unchanged tables/views keep the same URL
@@ -4338,12 +4602,12 @@ interface components {
             /**
              * @description Thumbprint for the cross-cutting "default" bundle (everything outside
              *     `tables.*` / `choices.*`). Compose into the URL produced by
-             *     <see cref="!:Routes.Localizations.GetDefaultBundleRoute" />.
+             *     string Localizations.GetDefaultBundleRoute(string locale, string thumbprint).
              */
             bundle: string;
             /**
              * @description Thumbprint per table logical name. The matching URL —
-             *     <see cref="!:Routes.Localizations.GetTableBundleRoute" /> — returns every
+             *     string Localizations.GetTableBundleRoute(string tableName, string locale, string thumbprint) — returns every
              *     `tables.{name}.*` string PLUS the global `choices.{set}.*`
              *     strings the table's columns reference.
              */
@@ -4352,7 +4616,7 @@ interface components {
             };
             /**
              * @description Thumbprint per view id (lowercased GUID, no braces). The matching URL —
-             *     <see cref="!:Routes.Localizations.GetViewBundleRoute" /> — returns every
+             *     string Localizations.GetViewBundleRoute(string viewId, string locale, string thumbprint) — returns every
              *     `tables.{owningTable}.views.{viewId}.*` string for that view. The
              *     owning table is resolved server-side, so the client only needs the view id.
              */
@@ -4360,6 +4624,144 @@ interface components {
                 [key: string]: string;
             };
         };
+        /**
+         * @description Admin-facing snapshot of the string-localization pipeline: the static configuration
+         *     that drives the warmup loaders plus the runtime per-source load records produced by
+         *     the most recent warmup. Surfaced via Task&lt;LocalizationOverview&gt; IPowerPortalsProService.GetLocalizationOverviewAsync().
+         */
+        LocalizationOverview: {
+            /**
+             * @description The static configuration: registered directories, files, table-localization mode,
+             *     and supported cultures. Reflects the options at the time the overview was captured.
+             */
+            configuration: components["schemas"]["LocalizationPipelineConfiguration"];
+            /**
+             * @description Per-source records from the most recent warmup, in the order they were loaded.
+             *     Empty when the cache hasn't been warmed yet (rare — startup runs the warmup
+             *     hook synchronously). Later entries override earlier ones on a per-key basis;
+             *     the int LocalizationSourceLoad.KeysOverriding column on each row shows
+             *     how many of its keys replaced a non-empty value already in the cache.
+             */
+            sourceLoads: components["schemas"]["LocalizationSourceLoad"][];
+            /**
+             * Format: date-time
+             * @description When the most recent warmup completed (UTC). `null` if no warmup has run.
+             */
+            lastReloadedOn?: null | string;
+        };
+        /**
+         * @description Static view of the configuration that drives the localization warmup, suitable for
+         *     rendering in an admin "what's wired up" panel alongside the runtime source list.
+         */
+        LocalizationPipelineConfiguration: {
+            /**
+             * @description When `true`, every table's metadata is loaded; IReadOnlyList&lt;string&gt; LocalizationPipelineConfiguration.TablesToLocalize
+             *     is ignored. Defaults to `true` on a fresh `LocalizationOptions`.
+             */
+            localizeAllAvailableTables: boolean;
+            /**
+             * @description The table logical names configured via `options.AddTableToLocalize(...)`.
+             *     Only honored when bool LocalizationPipelineConfiguration.LocalizeAllAvailableTables is `false`.
+             */
+            tablesToLocalize: string[];
+            /**
+             * @description The relative directory paths registered via `options.AddLocalizationDirectory(...)`.
+             *     JSON files in these directories load LAST in the warmup, so they override anything
+             *     supplied by Dataverse metadata or web resources.
+             */
+            localizationDirectories: string[];
+            /** @description Individual file paths registered via `options.AddLocalizationFile(...)`. */
+            localizationFiles: string[];
+            /**
+             * @description The web-resource name pattern the cache uses to discover Dataverse-hosted JSON
+             *     localization files. Hard-coded today; surfaced here so the admin UI doesn't have
+             *     to reinvent the literal.
+             */
+            webResourcePathPattern: string;
+            /** @description The default culture configured on CultureInfo LocalizationOptions.DefaultCulture. */
+            defaultCulture: string;
+        };
+        /**
+         * @description Discriminates the three localization source kinds the cache pulls from at warmup.
+         *     Underlying integer values are pinned so JSON / numeric serialization is stable
+         *     across releases — append new members with the next unused number and never
+         *     renumber existing entries.
+         * @enum {integer}
+         */
+        LocalizationSourceKind: 0 | 1 | 2;
+        /**
+         * @description One row in the runtime load-events grid: a single loader invocation against a single
+         *     source (one Dataverse table's metadata, one web resource, one disk file).
+         */
+        LocalizationSourceLoad: {
+            /**
+             * Format: int32
+             * @description 1-based load order. Combined with DateTimeOffset LocalizationSourceLoad.LoadedAt, gives the precedence
+             *     chain: lower-order loads' values can be overridden by higher-order loads.
+             */
+            loadOrder: number | string;
+            /**
+             * @description Stable identifier for this source, suitable for keying download endpoints
+             *     (e.g. `"folder:Resources/app.fr.json"`, `"webresource:/PowerPortalsPro/Localization/tables.fr.json"`,
+             *     `"metadata:account"`). Stable across reloads of the same configuration.
+             */
+            sourceId: string;
+            /** @description The kind of source this row represents — drives the icon / grouping in the UI. */
+            kind: components["schemas"]["LocalizationSourceKind"];
+            /**
+             * @description Human-readable name for the source — the table logical name, the web resource
+             *     name, or the file path (absolute, as resolved by the loader).
+             */
+            displayName: string;
+            /**
+             * @description The cultures (two-letter ISO codes for metadata, filename-derived for JSON) this
+             *     source contributed strings to. A Dataverse table contributes to every culture
+             *     with an installed language pack; a JSON file contributes to exactly one.
+             */
+            cultures: string[];
+            /**
+             * Format: int32
+             * @description Total number of distinct keys this source contributed across all cultures
+             *     (sum of per-culture key counts).
+             */
+            keysContributed: number | string;
+            /**
+             * Format: int32
+             * @description Of int LocalizationSourceLoad.KeysContributed, how many replaced a non-empty value an earlier
+             *     source had already stored. Useful for spotting which JSON file is actually
+             *     overriding Dataverse-supplied translations.
+             */
+            keysOverriding: number | string;
+            /**
+             * Format: int64
+             * @description Wall-clock duration of the load in milliseconds.
+             */
+            durationMs: number | string;
+            /**
+             * @description Terminal status — LocalizationSourceStatus.Loaded for success,
+             *     LocalizationSourceStatus.Failed when the loader threw (with
+             *     string? LocalizationSourceLoad.Error populated), or LocalizationSourceStatus.Skipped
+             *     when the source was discovered but ineligible (e.g. an empty file).
+             */
+            status: components["schemas"]["LocalizationSourceStatus"];
+            /**
+             * @description Exception message when LocalizationSourceStatus LocalizationSourceLoad.Status is LocalizationSourceStatus.Failed,
+             *     otherwise `null`.
+             */
+            error?: null | string;
+            /**
+             * Format: date-time
+             * @description When this individual source finished loading (UTC).
+             */
+            loadedAt: string;
+        };
+        /**
+         * @description Terminal status of a single source's load. Underlying integer values are pinned
+         *     so JSON / numeric serialization is stable across releases — append new members
+         *     with the next unused number and never renumber existing entries.
+         * @enum {integer}
+         */
+        LocalizationSourceStatus: 0 | 1 | 2;
         /**
          * @description Credentials submitted to `POST /api/auth/login`. Same-origin SPAs only need to
          *     post this body; the server sets the auth cookie on success and returns a
@@ -4392,9 +4794,9 @@ interface components {
          *     so the client can branch UI behavior without inspecting HTTP status codes.
          *
          *     Members carry explicit integer values: this enum ships in JSON wire payloads, so
-         *     non-Blazor consumers (React, Vue, mobile clients) compare against the numeric
-         *     representation. Pinning the values prevents accidental drift if a future
-         *     refactor reorders or inserts members.
+         *     the JSON numeric representation is a stable contract. Pinning the
+         *     values prevents accidental drift if a future refactor reorders or
+         *     inserts members.
          * @enum {integer}
          */
         LoginResult: 0 | 1 | 2 | 3 | 4;
@@ -4581,6 +4983,43 @@ interface components {
                 [key: string]: components["schemas"]["ColumnValueBase"];
             };
         };
+        /**
+         * @description Stable, environment-wide settings sourced from the Dataverse `organization`
+         *                 record. Cached server-side (they change very rarely — only when an admin updates
+         *                 the org record) and re-served to clients via `/api/organizationSettings` so
+         *                 the front end can prime defaults without firing its own Dataverse trip.
+         *                             Two categories of fields live here today:
+         *                 * Currency OrganizationSettings.DefaultCurrency — used by create-mode editors to render the
+         *                   correct currency symbol on new records before they're saved.
+         *     * IReadOnlyList&lt;string&gt; OrganizationSettings.BlockedFileExtensions + long OrganizationSettings.MaxUploadFileSizeInBytes
+         *                   — file-upload constraints clients mirror so users get a friendly client-side
+         *                   rejection instead of a round-trip failure.
+         *                 New properties are appended as additional organization-level defaults become
+         *                 useful client-side (locale, base language, formatting policies, etc.).
+         */
+        OrganizationSettings: {
+            /**
+             * @description The org's base currency, resolved from the `organization.basecurrencyid`
+             *     lookup. `MoneyEdit` consumes this in create mode so a brand-new record
+             *     displays the right currency symbol before the user picks one or saves.
+             */
+            defaultCurrency: components["schemas"]["Currency"];
+            /**
+             * @description Lowercase file extensions (without the leading dot) that Dataverse refuses to
+             *     accept as uploads — for example `"svg"`, `"exe"`, `"bat"`. Sourced
+             *     from the organization's `blockedattachments` setting (a semicolon-delimited
+             *     string in Dataverse, parsed and normalised here). Clients reject these client-side
+             *     before the upload round-trips.
+             */
+            blockedFileExtensions: string[];
+            /**
+             * Format: int64
+             * @description Maximum upload size for file attachments and file-column payloads, in bytes.
+             *     Sourced from the organization's `maxuploadfilesize` setting. Clients
+             *     compare file byte length directly against this for a pre-upload check.
+             */
+            maxUploadFileSizeInBytes: number | string;
+        };
         /** @description Paging metadata for a Dataverse query response. */
         PagingInfo: {
             /**
@@ -4755,8 +5194,7 @@ interface components {
         };
         /**
          * @description Outcome of a RegisterRequest. Members carry explicit integer
-         *     values so non-Blazor consumers comparing against the JSON wire form get a
-         *     stable contract across reorderings.
+         *     values so the JSON wire form is a stable contract across reorderings.
          * @enum {integer}
          */
         RegisterResult: 0 | 1 | 2;
@@ -4863,8 +5301,8 @@ interface components {
         };
         /**
          * @description Outcome of `POST /api/auth/reset-password`. Members carry explicit
-         *     integer values so non-Blazor consumers comparing against the JSON wire form
-         *     get a stable contract across reorderings.
+         *     integer values so the JSON wire form is a stable contract across
+         *     reorderings.
          * @enum {integer}
          */
         ResetPasswordResult: 0 | 1 | 2;
@@ -4921,7 +5359,7 @@ interface components {
              *     the column matching `TableMetadata.PrimaryNameColumn` AND
              *     belonging to the view's main table (not a linked-entity column).
              *     Clients use this to optionally render the cell as a clickable link
-             *     that triggers the grid's edit action (see Blazor's
+             *     that triggers the grid's edit action (gated by
              *     `AllowNavigateOnPrimaryNameClick`). At most one column per
              *     view will have this set; consumers can safely use it to decorate
              *     "open this record"-style links without per-row metadata lookups.
@@ -4995,8 +5433,8 @@ interface components {
         };
         /**
          * @description Outcome of `POST /api/auth/switch-identity`. Members carry explicit
-         *     integer values so non-Blazor consumers comparing against the JSON wire form
-         *     get a stable contract across reorderings.
+         *     integer values so the JSON wire form is a stable contract across
+         *     reorderings.
          * @enum {integer}
          */
         SwitchIdentityResult: 0 | 1 | 2 | 3;
@@ -5045,6 +5483,7 @@ interface components {
             formattedValues?: {
                 [key: string]: string;
             };
+            currency?: null | components["schemas"]["Currency"];
             /** @description True when at least one column value has been changed since the record was loaded or void TableRecord.ResetState() was called. */
             isDirty?: boolean;
             /** Format: uuid */
@@ -5067,6 +5506,121 @@ interface components {
          * @enum {integer}
          */
         TableSecurityPermission: 0 | 1 | 2 | 4 | 8 | 16 | 32 | 63;
+        /**
+         * @description One target language's translated output plus how many strings were freshly translated
+         *     versus reused from the Dataverse translation memory.
+         */
+        TranslatedFile: {
+            /** @description The portal culture this file was translated into (e.g. `"fr-FR"`). */
+            targetCultureCode: string;
+            /** @description Suggested filename for this language's download (e.g. `"app.fr-FR.json"`). */
+            fileName: string;
+            /**
+             * Format: int32
+             * @description Number of strings sent to the translation provider for this language this run.
+             */
+            translatedCount: number | string;
+            /**
+             * Format: int32
+             * @description Number of strings that came from the Dataverse translation memory (not re-sent to the provider).
+             */
+            reusedCount: number | string;
+            /**
+             * Format: byte
+             * @description UTF-8-encoded translated JSON body, in the same nested-object shape as the source.
+             */
+            content: string;
+        };
+        /**
+         * @description Admin-facing description of whether the localization-translation feature is usable in
+         *     the current environment, returned by Task&lt;TranslationAvailability&gt; IPowerPortalsProService.GetTranslationAvailabilityAsync().
+         *     Drives whether the `LocalizationTranslator` UI shows its upload/translate panel, an
+         *     "install the managed solution" prompt, or nothing at all.
+         */
+        TranslationAvailability: {
+            /**
+             * @description `true` when a translation provider is registered and its credentials are configured
+             *             (the consumer called one of the `AddPowerPortalsPro&lt;Provider&gt;TranslationService()`
+             *             methods — Azure, DeepL, Google, … — and supplied the provider's key). When `false` the UI
+             *             renders nothing — translation is a host-wiring concern the admin can't self-serve.
+             */
+            isConfigured: boolean;
+            /**
+             * @description `true` when the translation managed solution (default unique name
+             *             `PowerPortalsProLocalization`) is installed in the connected environment, so the
+             *             translation-memory tables exist. When bool TranslationAvailability.IsConfigured is `true` but this
+             *             is `false`, the UI shows a prompt to install the solution.
+             */
+            isSolutionInstalled: boolean;
+            /**
+             * @description The candidate target languages — the portal's supported cultures, each annotated with
+             *     whether the configured translation provider can translate to it. Cultures the provider
+             *     doesn't support are still returned (so the admin sees them) but flagged via
+             *     bool TranslationLanguageOption.IsSupportedByProvider so the UI can disable them.
+             *     Empty when bool TranslationAvailability.IsConfigured is `false`.
+             */
+            targetLanguages: components["schemas"]["TranslationLanguageOption"][];
+        };
+        /**
+         * @description One selectable target language in the translation UI: a portal-supported culture paired
+         *     with the translation-provider language code it maps to (when the provider supports it).
+         */
+        TranslationLanguageOption: {
+            /** @description The portal culture code (e.g. `"fr-FR"`) — what the UI shows and the output file is named for. */
+            cultureCode: string;
+            /** @description Human-readable language/culture display name (e.g. `"French (France)"`). */
+            displayName: string;
+            /**
+             * @description The translation-provider language code this culture maps to (e.g. `"fr"`), or `null`
+             *     when the configured provider doesn't support the culture's language.
+             */
+            providerLanguageCode?: null | string;
+            /** @description `true` when the configured provider can translate to this culture (string? TranslationLanguageOption.ProviderLanguageCode is non-null). */
+            isSupportedByProvider?: boolean;
+        };
+        /**
+         * @description Request to translate one uploaded localization file into one or more target languages,
+         *     passed to Task&lt;TranslationResult&gt; IPowerPortalsProService.TranslateLocalizationFileAsync(TranslationRequest request).
+         */
+        TranslationRequest: {
+            /** @description BCP-47 source language code (e.g. `"en"`), auto-detected from the filename but admin-editable. */
+            sourceLanguage: string;
+            /** @description The portal culture codes to translate into (the string TranslationLanguageOption.CultureCode values the admin selected). */
+            targetCultureCodes: string[];
+            /** @description The original uploaded filename (e.g. `"app.en.json"`) — used to name the per-language output files. */
+            fileName: string;
+            /**
+             * Format: byte
+             * @description The raw uploaded file bytes (UTF-8 JSON, optionally wrapped in a `var x = {...}` assignment, which the translator tolerates).
+             */
+            sourceContent: string;
+        };
+        /**
+         * @description Result of a translate operation: one TranslatedFile per requested target
+         *     language plus a single zip of all of them, returned by
+         *     Task&lt;TranslationResult&gt; IPowerPortalsProService.TranslateLocalizationFileAsync(TranslationRequest request).
+         */
+        TranslationResult: {
+            /** @description One entry per requested target language, each with its own counts and downloadable content. */
+            files: components["schemas"]["TranslatedFile"][];
+            /**
+             * Format: byte
+             * @description All IReadOnlyList&lt;TranslatedFile&gt; TranslationResult.Files packaged into a single zip — backs the "Download all" button.
+             */
+            zipContent: string;
+            /** @description Suggested filename for the byte[] TranslationResult.ZipContent download. */
+            zipFileName: string;
+            /**
+             * Format: int32
+             * @description Total strings translated via the provider across all languages this run (sum of int TranslatedFile.TranslatedCount).
+             */
+            totalTranslated: number | string;
+            /**
+             * Format: int32
+             * @description Total strings satisfied from the Dataverse translation memory across all languages (sum of int TranslatedFile.ReusedCount).
+             */
+            totalReused: number | string;
+        };
         /**
          * @description Snapshot of the user's two-factor configuration, returned by
          *     `GET /api/auth/manage/2fa`. Drives the Manage/TwoFactorAuthentication
@@ -5240,6 +5794,7 @@ type ConfirmEmailResponse = Schemas$1['ConfirmEmailResponse'];
 type ResendEmailConfirmationRequest = Schemas$1['ResendEmailConfirmationRequest'];
 type CurrentUserInfo = Schemas$1['CurrentUserInfo'];
 type ExternalLoginProviderInfo = Schemas$1['ExternalLoginProviderInfo'];
+type AuthOptionsResponse = Schemas$1['AuthOptionsResponse'];
 type PendingExternalLoginResponse = Schemas$1['PendingExternalLoginResponse'];
 type ConfirmExternalLoginRequest = Schemas$1['ConfirmExternalLoginRequest'];
 type ConfirmExternalLoginResponse = Schemas$1['ConfirmExternalLoginResponse'];
@@ -5270,16 +5825,16 @@ type PersonalDataResponse = Schemas$1['PersonalDataResponse'];
 type DeletePersonalDataRequest = Schemas$1['DeletePersonalDataRequest'];
 type DeletePersonalDataResponse = Schemas$1['DeletePersonalDataResponse'];
 /**
- * SPA-facing wrapper over the framework's `/api/auth/*` endpoints — the React equivalent
- * of `IAuthService` from `PowerPortalsPro.Web.Common.Auth`. Method names mirror the C#
- * interface so a Blazor dev reading both sides finds the same vocabulary.
+ * SPA-facing wrapper over the framework's `/api/auth/*` endpoints — sign-
+ * in, profile, 2FA, external login, forgot-password, registration, and
+ * confirmation flows.
  *
  * Cookie auth flows automatically (the underlying {@link Transport} sends
  * `credentials: 'include'`), so a successful `loginAsync` leaves subsequent calls
  * authenticated without any token wiring on the React side.
  *
  * Mid-flow steps (`login → 2FA`, `register → confirm email`, `forgot → reset`) each
- * surface as their own method so the consuming SPA owns its routing/UX between steps —
+ * surface as their own method so the consuming SPA owns its routing/UX between steps
  * same design as the C# interface.
  */
 declare class AuthClient {
@@ -5321,8 +5876,13 @@ declare class AuthClient {
      * startup to decide whether to render signed-in UI vs. the login flow.
      */
     getCurrentUserAsync(signal?: AbortSignal): Promise<CurrentUserInfo>;
-    /** Lists the configured external (OAuth) login providers (Microsoft, Google, …). */
-    getExternalLoginProvidersAsync(signal?: AbortSignal): Promise<readonly ExternalLoginProviderInfo[]>;
+    /**
+     * Anonymous auth options for the sign-in UI: whether the portal accepts local
+     * username/password accounts (`localAccountsEnabled`) plus the configured external
+     * providers — one round-trip the login page uses to decide whether to render the
+     * local form / register + reset links and which provider buttons to show.
+     */
+    getAuthOptionsAsync(signal?: AbortSignal): Promise<AuthOptionsResponse>;
     /**
      * Reads the in-flight external-login cookie set by an OAuth callback. Returns
      * `null` when no callback is in flight (the endpoint replies 204) — the client
@@ -5405,43 +5965,56 @@ declare class AuthClient {
  * Aggregate function applied to a column in an aggregate FetchXML query.
  */
 declare const AggregateType: {
+    /** No aggregation. */
     readonly None: 0;
+    /** Count of rows (including nulls). */
     readonly Count: 1;
+    /** Count of rows where the column is not null. */
     readonly CountColumn: 2;
+    /** Sum of values. */
     readonly Sum: 3;
+    /** Arithmetic mean of values. */
     readonly Avg: 4;
+    /** Minimum value. */
     readonly Min: 5;
+    /** Maximum value. */
     readonly Max: 6;
 };
 type AggregateType = (typeof AggregateType)[keyof typeof AggregateType];
 /**
  * Compression format for the archive produced by
- * <see cref="!:Services.IPowerPortalsProService.CreateFileArchiveAsync" />.
+ * `IPowerPortalsProService.CreateFileArchiveAsync`.
  * Currently only ArchiveFormat.Zip is supported; the enum is open-ended so
  * future formats can land without breaking the wire schema.
  */
 declare const ArchiveFormat: {
+    /** Standard ZIP archive (application/zip, .zip extension). Built via ZipArchive with Optimal. */
     readonly Zip: 0;
 };
 type ArchiveFormat = (typeof ArchiveFormat)[keyof typeof ArchiveFormat];
 /**
  * Outcome of `POST /api/auth/manage/email/change`. Members carry explicit
- * integer values so non-Blazor consumers comparing against the JSON wire form
- * get a stable contract across reorderings.
+ * integer values so the JSON wire form is a stable contract across
+ * reorderings.
  */
 declare const ChangeEmailResult: {
+    /** A confirmation email was sent to the new address. The change does not take effect until the user clicks the link. */
     readonly ConfirmationEmailSent: 0;
+    /** The submitted email matches the user's current email. Nothing was sent. The client should show a "this is already your email" message. */
     readonly SameAsCurrentEmail: 1;
 };
 type ChangeEmailResult = (typeof ChangeEmailResult)[keyof typeof ChangeEmailResult];
 /**
  * Outcome of `POST /api/auth/manage/password/change`. Members carry
- * explicit integer values so non-Blazor consumers comparing against the JSON
- * wire form get a stable contract across reorderings.
+ * explicit integer values so the JSON wire form is a stable contract
+ * across reorderings.
  */
 declare const ChangePasswordResult: {
+    /** The password was changed. The auth cookie has been refreshed to pick up the new security stamp so other sessions are invalidated. */
     readonly Success: 0;
+    /** The supplied old password did not match the current password. The client should show an "incorrect current password" error and allow retry. */
     readonly IncorrectOldPassword: 1;
+    /** The new password did not satisfy the host's IdentityOptions.Password rules. Errors carries the per-rule messages so the client can show actionable feedback. */
     readonly InvalidPassword: 2;
 };
 type ChangePasswordResult = (typeof ChangePasswordResult)[keyof typeof ChangePasswordResult];
@@ -5455,16 +6028,27 @@ type ChangePasswordResult = (typeof ChangePasswordResult)[keyof typeof ChangePas
  * current culture.
  */
 declare const ChartDateGrouping: {
+    /** No date grouping — the column is grouped by its raw value. */
     readonly None: 0;
+    /** Group by day (dategrouping="day"). Label: day number. */
     readonly Day: 1;
+    /** Group by ISO week (dategrouping="week"). Label: week number. */
     readonly Week: 2;
+    /** Group by calendar month (dategrouping="month"). Label: abbreviated month name (Jan, Feb, …) in the current culture. */
     readonly Month: 3;
+    /** Group by calendar quarter (dategrouping="quarter"). Label: quarter number. */
     readonly Quarter: 4;
+    /** Group by calendar year (dategrouping="year"). Label: year. */
     readonly Year: 5;
+    /** Group by month + year. Label: "Jan 2024". */
     readonly MonthAndYear: 6;
+    /** Group by day + month. Label: "15 Jan". */
     readonly DayAndMonth: 7;
+    /** Group by day + month + year. Label: "15 Jan 2024". */
     readonly DayAndMonthAndYear: 8;
+    /** Group by ISO week + year. Label: "W15 2024". */
     readonly WeekAndYear: 9;
+    /** Group by quarter + year. Label: "Q1 2024". */
     readonly QuarterAndYear: 10;
 };
 type ChartDateGrouping = (typeof ChartDateGrouping)[keyof typeof ChartDateGrouping];
@@ -5472,41 +6056,69 @@ type ChartDateGrouping = (typeof ChartDateGrouping)[keyof typeof ChartDateGroupi
  * Identifies the data type of a Dataverse column. Values 0–20 mirror the Dataverse SDK's `AttributeTypeCode`; values 40+ are PowerPortalsPro-specific column types not present in Dataverse.
  */
 declare const ColumnType: {
+    /** A Boolean attribute. Value = 0. */
     readonly Boolean: 0;
+    /** An attribute that represents a customer. Value = 1. */
     readonly Customer: 1;
+    /** A date/time attribute. Value = 2. */
     readonly DateTime: 2;
+    /** A decimal attribute. Value = 3. */
     readonly Decimal: 3;
+    /** A double attribute. Value = 4. */
     readonly Double: 4;
+    /** An integer attribute. Value = 5. */
     readonly Integer: 5;
+    /** A lookup attribute. Value = 6. */
     readonly Lookup: 6;
+    /** A memo attribute. Value = 7. */
     readonly Memo: 7;
+    /** A money attribute. Value = 8. */
     readonly Money: 8;
+    /** An owner attribute. Value = 9. */
     readonly Owner: 9;
+    /** A partylist attribute. Value = 10. */
     readonly PartyList: 10;
+    /** A picklist (single-select choice) attribute. Value = 11. */
     readonly Choice: 11;
+    /** A state attribute. Value = 12. */
     readonly State: 12;
+    /** A status attribute. Value = 13. */
     readonly Status: 13;
+    /** A string attribute. Value = 14. */
     readonly String: 14;
+    /** A unique identifier (GUID) attribute. Value = 15. */
     readonly Uniqueidentifier: 15;
+    /** An attribute that contains calendar rules. Value = 16. */
     readonly CalendarRules: 16;
+    /** An attribute that is created by the system at run time. Value = 17. */
     readonly Virtual: 17;
+    /** A big integer (long) attribute. Value = 18. */
     readonly BigInt: 18;
+    /** A managed property attribute. Value = 19. */
     readonly ManagedProperty: 19;
+    /** An entity name attribute. Value = 20. */
     readonly EntityName: 20;
+    /** A multi-select choice attribute. Value = 40. PowerPortalsPro-specific (not present in Dataverse AttributeTypeCode). */
     readonly MultiSelectChoice: 40;
+    /** A file attachment attribute. Value = 41. PowerPortalsPro-specific (not present in Dataverse AttributeTypeCode). */
     readonly File: 41;
+    /** An image attribute. Value = 42. PowerPortalsPro-specific (not present in Dataverse AttributeTypeCode). */
     readonly Image: 42;
 };
 type ColumnType = (typeof ColumnType)[keyof typeof ColumnType];
 /**
  * Outcome of `POST /api/auth/external-login/confirm`. Members carry
- * explicit integer values so non-Blazor consumers comparing against the JSON
- * wire form get a stable contract across reorderings.
+ * explicit integer values so the JSON wire form is a stable contract
+ * across reorderings.
  */
 declare const ConfirmExternalLoginResult: {
+    /** The external login was linked (creating a new local account if needed) and the user has been signed in. The auth cookie is set on the response. */
     readonly SignedIn: 0;
+    /** The account was created but the host requires email confirmation. A confirmation link has been sent; the user is NOT signed in yet. */
     readonly ConfirmationEmailSent: 1;
+    /** No external-login cookie was found — the user landed on the confirm endpoint without a fresh OAuth callback. The client should redirect back to the login page. */
     readonly NoPendingExternalLogin: 2;
+    /** Identity rejected the create / add-login operation (e.g. duplicate email already linked to a different account). Errors carries the per-rule messages. */
     readonly Failure: 3;
 };
 type ConfirmExternalLoginResult = (typeof ConfirmExternalLoginResult)[keyof typeof ConfirmExternalLoginResult];
@@ -5514,29 +6126,37 @@ type ConfirmExternalLoginResult = (typeof ConfirmExternalLoginResult)[keyof type
  * Specifies the date/time behavior of a DateTime column.
  */
 declare const DateTimeBehavior: {
+    /** Only the date portion is stored; no time component. */
     readonly DateOnly: 1;
+    /** The value is stored in UTC and converted to the user's local time zone for display. */
     readonly UserLocal: 2;
+    /** The value is stored and displayed exactly as entered, without time zone conversion. */
     readonly TimeZoneIndependent: 3;
 };
 type DateTimeBehavior = (typeof DateTimeBehavior)[keyof typeof DateTimeBehavior];
 /**
  * Outcome of `POST /api/auth/manage/personal-data/delete`. Members carry
- * explicit integer values so non-Blazor consumers comparing against the JSON
- * wire form get a stable contract across reorderings.
+ * explicit integer values so the JSON wire form is a stable contract
+ * across reorderings.
  */
 declare const DeletePersonalDataResult: {
+    /** The account was deleted and the auth cookie has been cleared. */
     readonly Success: 0;
+    /** The user has a local password set, and one was supplied, but it did not match. The client should show an "incorrect password" error and allow retry. */
     readonly IncorrectPassword: 1;
+    /** The user has a local password set but the request body's password field was empty. The client should prompt for the password and resubmit. Distinct from IncorrectPassword so the UI can choose between "please enter your password" and "that password is wrong." */
     readonly RequireLocalPassword: 2;
 };
 type DeletePersonalDataResult = (typeof DeletePersonalDataResult)[keyof typeof DeletePersonalDataResult];
 /**
  * Which Dataverse table backs an external-login candidate. Members carry
- * explicit integer values so non-Blazor consumers comparing against the JSON
- * wire form get a stable contract across reorderings.
+ * explicit integer values so the JSON wire form is a stable contract
+ * across reorderings.
  */
 declare const ExternalLoginCandidateKind: {
+    /** The candidate is a Dataverse contact record. */
     readonly Contact: 0;
+    /** The candidate is a Dataverse systemuser record. */
     readonly SystemUser: 1;
 };
 type ExternalLoginCandidateKind = (typeof ExternalLoginCandidateKind)[keyof typeof ExternalLoginCandidateKind];
@@ -5544,7 +6164,9 @@ type ExternalLoginCandidateKind = (typeof ExternalLoginCandidateKind)[keyof type
  * Determines how the server returns the archive bytes to the caller.
  */
 declare const FileArchiveResponseFormat: {
+    /** Returns the raw archive bytes as the response body, with Content-Type: application/zip (or the matching MIME for the chosen ArchiveFormat) and a Content-Disposition: attachment; filename=… header. The caller hands the response directly to the browser's download path — no base64 round-trip. Default mode. */
     readonly BinaryStream: 0;
+    /** Returns a JSON envelope (FileArchiveJsonResponse) that wraps the archive's bytes as base64. Useful when the consumer wants to inspect headers / filename / size programmatically before triggering a download, or when the host environment can't stream binary responses (some test harnesses, some service workers). Trades ~33% wire-size overhead for the JSON wrapper. */
     readonly Json: 1;
 };
 type FileArchiveResponseFormat = (typeof FileArchiveResponseFormat)[keyof typeof FileArchiveResponseFormat];
@@ -5552,15 +6174,25 @@ type FileArchiveResponseFormat = (typeof FileArchiveResponseFormat)[keyof typeof
  * Join type used on a FetchXML link-entity.
  */
 declare const JoinOperator: {
+    /** Inner join — only matching rows are returned. */
     readonly Inner: 0;
+    /** Left outer join — unmatched parent rows are returned with null link columns. */
     readonly LeftOuter: 1;
+    /** Natural join. */
     readonly Natural: 2;
+    /** Match first row using cross apply. */
     readonly MatchFirstRowUsingCrossApply: 3;
+    /** In join — semi-join used for subqueries. */
     readonly In: 4;
+    /** Exists join — semi-join evaluating existence. */
     readonly Exists: 5;
+    /** Any-match semi-join. */
     readonly Any: 6;
+    /** Inverse of Any. */
     readonly NotAny: 7;
+    /** All-match semi-join. */
     readonly All: 8;
+    /** Inverse of All. */
     readonly NotAll: 9;
 };
 type JoinOperator = (typeof JoinOperator)[keyof typeof JoinOperator];
@@ -5569,26 +6201,33 @@ type JoinOperator = (typeof JoinOperator)[keyof typeof JoinOperator];
  * so the client can branch UI behavior without inspecting HTTP status codes.
  *
  * Members carry explicit integer values: this enum ships in JSON wire payloads, so
- * non-Blazor consumers (React, Vue, mobile clients) compare against the numeric
- * representation. Pinning the values prevents accidental drift if a future
- * refactor reorders or inserts members.
+ * the JSON numeric representation is a stable contract. Pinning the
+ * values prevents accidental drift if a future refactor reorders or
+ * inserts members.
  */
 declare const LoginResult: {
+    /** Credentials were accepted and the auth cookie has been set. The client should navigate to the post-login destination (typically ReturnUrl). */
     readonly Success: 0;
+    /** Credentials were accepted but the account requires a second factor. The server has sent the 2FA code (e.g., via email) and is waiting for a follow-up call to POST /api/auth/login/2fa. No auth cookie is set yet. */
     readonly RequiresTwoFactor: 1;
+    /** The email/password pair did not match any account, or the password was wrong. The client should show a generic "invalid credentials" message — the server deliberately does not distinguish between "no such email" and "wrong password" to avoid account-enumeration attacks. */
     readonly InvalidCredentials: 2;
+    /** The account exists and the password matched, but the email address has not been confirmed and the host configured SignIn.RequireConfirmedAccount. The client should redirect to the registration-confirmation flow. */
     readonly EmailNotConfirmed: 3;
+    /** The account is locked out (too many failed attempts, manual lockout, etc.). The client should show the lockout page. */
     readonly LockedOut: 4;
 };
 type LoginResult = (typeof LoginResult)[keyof typeof LoginResult];
 /**
  * Outcome of a RegisterRequest. Members carry explicit integer
- * values so non-Blazor consumers comparing against the JSON wire form get a
- * stable contract across reorderings.
+ * values so the JSON wire form is a stable contract across reorderings.
  */
 declare const RegisterResult: {
+    /** The account was created and a confirmation email has been sent. The user is NOT signed in yet — they must click the confirmation link first. */
     readonly ConfirmationEmailSent: 0;
+    /** The account was created and the user has been signed in directly (the host did not configure SignIn.RequireConfirmedAccount). */
     readonly SignedIn: 1;
+    /** An account with the same email already exists. The server returns this rather than silently succeeding to give the client an opportunity to surface a clear error, at the cost of allowing email enumeration. Hosts that prefer the enumeration- resistant path should treat this as success client-side. */
     readonly EmailAlreadyInUse: 2;
 };
 type RegisterResult = (typeof RegisterResult)[keyof typeof RegisterResult];
@@ -5605,7 +6244,9 @@ type RegisterResult = (typeof RegisterResult)[keyof typeof RegisterResult];
  * relationship is rejected by the server at filter-apply time.
  */
 declare const RelationshipFilterMode: {
+    /** Return records currently associated with ParentRecord via the named relationship. For one-to-many, AND-merges a referencingColumn == parentRecord.Id condition. For many-to-many, AND-merges an intersect link-entity plus a condition on the parent-side intersect column. */
     readonly IncludeExistingRecords: 0;
+    /** Return records that are NOT currently associated with ParentRecord. Many-to-many only — AND-merges a LEFT OUTER intersect link-entity (filtered to the parent's intersect rows) and an outer null-check on the parent-side intersect column, so unrelated records survive but related records get filtered out. */
     readonly ExcludeExistingRecords: 1;
 };
 type RelationshipFilterMode = (typeof RelationshipFilterMode)[keyof typeof RelationshipFilterMode];
@@ -5613,32 +6254,43 @@ type RelationshipFilterMode = (typeof RelationshipFilterMode)[keyof typeof Relat
  * Specifies whether a column value is required.
  */
 declare const RequiredLevel: {
+    /** No requirements are specified. */
     readonly None: 0;
+    /** The column is required by the system and cannot be null. */
     readonly SystemRequired: 1;
+    /** The column is required by the application and should have a value. */
     readonly ApplicationRequired: 2;
+    /** It is recommended that the column has a value, but it is not enforced. */
     readonly Recommended: 3;
 };
 type RequiredLevel = (typeof RequiredLevel)[keyof typeof RequiredLevel];
 /**
  * Outcome of `POST /api/auth/reset-password`. Members carry explicit
- * integer values so non-Blazor consumers comparing against the JSON wire form
- * get a stable contract across reorderings.
+ * integer values so the JSON wire form is a stable contract across
+ * reorderings.
  */
 declare const ResetPasswordResult: {
+    /** The password was reset and the user can now sign in with the new password. */
     readonly Success: 0;
+    /** The token was missing, malformed, expired, or already used. The client should redirect the user to the "request a new reset link" flow. */
     readonly InvalidOrExpiredToken: 1;
+    /** The new password did not satisfy the host's password rules. The accompanying ProblemDetails (in the failed-validation HTTP 400) carries the per-rule error messages from IdentityResult.Errors. */
     readonly InvalidPassword: 2;
 };
 type ResetPasswordResult = (typeof ResetPasswordResult)[keyof typeof ResetPasswordResult];
 /**
  * Outcome of `POST /api/auth/switch-identity`. Members carry explicit
- * integer values so non-Blazor consumers comparing against the JSON wire form
- * get a stable contract across reorderings.
+ * integer values so the JSON wire form is a stable contract across
+ * reorderings.
  */
 declare const SwitchIdentityResult: {
+    /** The alt identity was signed in and the auth cookie has been swapped. */
     readonly Switched: 0;
+    /** The current principal has no alt-identity claim — there is nothing to switch to. */
     readonly NoAltIdentity: 1;
+    /** The alt identity referenced by the claim no longer exists in Dataverse (or is disabled). */
     readonly AltIdentityNotFound: 2;
+    /** The current request is unauthenticated. */
     readonly NotAuthenticated: 3;
 };
 type SwitchIdentityResult = (typeof SwitchIdentityResult)[keyof typeof SwitchIdentityResult];
@@ -5646,13 +6298,21 @@ type SwitchIdentityResult = (typeof SwitchIdentityResult)[keyof typeof SwitchIde
  * Bit flags describing the security operations the current user can perform on a record.
  */
 declare const TableSecurityPermission: {
+    /** No permissions. */
     readonly None: 0;
+    /** The record can be read. */
     readonly Read: 1;
+    /** The record (or table) can have new records created. */
     readonly Create: 2;
+    /** The record can be modified. */
     readonly Write: 4;
+    /** The record can be deleted. */
     readonly Delete: 8;
+    /** The record can be appended to other records (used as the child of a relationship). */
     readonly Append: 16;
+    /** Other records can be appended to this record (used as the parent of a relationship). */
     readonly AppendTo: 32;
+    /** All permissions except Create. */
     readonly All: 63;
 };
 type TableSecurityPermission = (typeof TableSecurityPermission)[keyof typeof TableSecurityPermission];
@@ -5691,8 +6351,9 @@ type BaseDataPoint = Schemas['DataPointBase'];
 type DataverseDataPoint = Schemas['DataPointDataverseDataPoint'];
 type ChartLinkedEntity = Schemas['ChartLinkedEntity'];
 type FileInfo = Schemas['FileInfo'];
-type EnvironmentFileSettings = Schemas['EnvironmentFileSettings'];
 type CreateFileArchiveRequest = Schemas['CreateFileArchiveRequest'];
+type OrganizationSettings = Schemas['OrganizationSettings'];
+type Currency = Schemas['Currency'];
 /**
  * Client-side result of {@link PowerPortalsProClient.createFileArchiveAsync}.
  * Carries the archive bytes plus the metadata derived from the server's
@@ -5710,17 +6371,37 @@ interface FileArchiveResult {
 }
 type LocalizationBundleManifest = Schemas['LocalizationBundleManifest'];
 type LocalizationManifestForLocale = Schemas['LocalizationManifestForLocale'];
+type TranslationAvailability = Schemas['TranslationAvailability'];
+type TranslationLanguageOption = Schemas['TranslationLanguageOption'];
+type TranslationRequest = Schemas['TranslationRequest'];
+type TranslationResult = Schemas['TranslationResult'];
+type TranslatedFile = Schemas['TranslatedFile'];
+type LocalizationOverview = Schemas['LocalizationOverview'];
+type LocalizationPipelineConfiguration = Schemas['LocalizationPipelineConfiguration'];
+type LocalizationSourceLoad = Schemas['LocalizationSourceLoad'];
+type LocalizationSourceKind = Schemas['LocalizationSourceKind'];
+type LocalizationSourceStatus = Schemas['LocalizationSourceStatus'];
 /**
- * SPA-facing wrapper over the framework's record / metadata / file endpoints under
- * `/api/*` — the React equivalent of `IPowerPortalsProService` from
- * `PowerPortalsPro.Web.Common`. Method names mirror the C# interface verbatim
- * (camel-cased) so a Blazor dev reading both languages finds the same vocabulary.
- *
- * Flat surface, no sub-namespacing — `IPowerPortalsProService` exposes everything
- * (CRUD, metadata, files, …) at the root in C#; this class follows the same shape.
+ * A localization file pulled from the per-source or merged download endpoint:
+ * the UTF-8 JSON bytes plus the server-suggested filename (parsed from the
+ * `Content-Disposition` header). Mirrors the C# `LocalizationDownload` shape so
+ * both stacks share one mental model. The download methods return `null` (not
+ * this) when the server has nothing for the requested source/culture (404).
+ */
+interface LocalizationFileDownload {
+    /** Server-suggested download filename (already includes the culture + `.json`). */
+    readonly fileName: string;
+    /** UTF-8-encoded JSON body. */
+    readonly data: Uint8Array;
+}
+type CacheClearResult = Schemas['CacheClearResult'];
+/**
+ * SPA-facing wrapper over the framework's record / metadata / file endpoints
+ * under `/api/*`. Flat surface, no sub-namespacing — CRUD, metadata, files,
+ * and aggregate-chart calls all live at the root.
  *
- * Authentication is a separate concern handled by {@link AuthClient}, mirroring the
- * `IAuthService` / `IPowerPortalsProService` split on the Blazor side.
+ * Authentication is a separate concern handled by {@link AuthClient}, which
+ * sits beside this class with its own surface.
  *
  * @example
  * ```ts
@@ -5739,10 +6420,9 @@ declare class PowerPortalsProClient {
     readonly transport: Transport;
     constructor(transportOrOptions?: Transport | TransportOptions);
     /**
-     * Creates a new record. URL is derived from `record.tableName`. Server marks all
-     * properties as modified before applying so column values arriving from JSON
-     * (which carry no dirty flags) round-trip the same way they do from Blazor's
-     * dirty-tracked records.
+     * Creates a new record. URL is derived from `record.tableName`. The server
+     * marks every property as modified before applying so column values
+     * arriving from JSON (which carry no dirty flags) round-trip correctly.
      */
     createRecordAsync(record: TableRecord$1, signal?: AbortSignal): Promise<CreateResponse>;
     /**
@@ -5750,6 +6430,71 @@ declare class PowerPortalsProClient {
      * omit it for the table's full set of columns visible to the caller.
      */
     retrieveRecordAsync(tableLogicalName: string, recordId: string, columns?: readonly string[], signal?: AbortSignal): Promise<TableRecord$1>;
+    /**
+     * Probes whether the localization-translation feature is usable: whether a translation
+     * provider is configured, whether the managed solution is installed, and the candidate
+     * target languages (the portal's cultures annotated with provider-translatability).
+     * SystemAdmin-gated.
+     */
+    getTranslationAvailabilityAsync(signal?: AbortSignal): Promise<TranslationAvailability>;
+    /**
+     * Translates an uploaded localization file into one or more target languages, reusing the
+     * Dataverse translation memory. Returns one file per language (base64 `content`) plus a zip
+     * of all and translated-vs-reused counts. SystemAdmin-gated.
+     */
+    translateLocalizationFileAsync(request: TranslationRequest, signal?: AbortSignal): Promise<TranslationResult>;
+    /**
+     * Reads the admin localization overview: the configured warmup pipeline plus the
+     * per-source load records (load order, source kind, cultures touched, key counts,
+     * how many keys overrode an earlier source, duration, status) from the most recent
+     * warmup. Backs the `<LocalizationAdmin />` panel. SystemAdmin-gated.
+     */
+    getLocalizationOverviewAsync(signal?: AbortSignal): Promise<LocalizationOverview>;
+    /**
+     * Downloads the JSON one source contributed to one culture during the most recent
+     * warmup — a translation-handoff snapshot. Returns `null` when the source/culture
+     * pair isn't tracked (the server answers 404 — cache cleared, source removed, or
+     * the culture has no entries for that source). SystemAdmin-gated.
+     */
+    downloadLocalizationSourceAsync(sourceId: string, culture: string, signal?: AbortSignal): Promise<LocalizationFileDownload | null>;
+    /**
+     * Downloads the merged JSON of every key the cache will serve for a culture (the
+     * post-merge winning value across all sources) — a complete-snapshot reference.
+     * Returns `null` when the culture has no entries (404). SystemAdmin-gated.
+     */
+    downloadMergedLocalizationsAsync(culture: string, signal?: AbortSignal): Promise<LocalizationFileDownload | null>;
+    /**
+     * Shared binary-download path for the two localization download endpoints. Reads
+     * the raw bytes via `response.arrayBuffer()` and derives the filename from the
+     * `Content-Disposition` header (matching {@link createFileArchiveAsync}). Maps a
+     * 404 to `null` so callers can show a "nothing to download" message instead of
+     * surfacing it as an error.
+     */
+    private downloadLocalizationFile;
+    /**
+     * Lists every registered server-side cache by name — the values that
+     * {@link clearCacheAsync} accepts. Backs the per-cache buttons on an admin
+     * "clear caches" page; render them sorted client-side for a stable order.
+     * SystemAdmin-gated.
+     */
+    getCacheNamesAsync(signal?: AbortSignal): Promise<readonly string[]>;
+    /**
+     * Clears every registered server-side cache and returns one
+     * {@link CacheClearResult} per cache (name, success flag, error, elapsed ms).
+     * Per-cache failures are reported in the result rows rather than thrown, so a
+     * single misbehaving cache doesn't abort the rest — inspect `succeeded` on each
+     * row. SystemAdmin-gated.
+     */
+    clearAllCachesAsync(signal?: AbortSignal): Promise<readonly CacheClearResult[]>;
+    /**
+     * Clears a single named cache (case-insensitive match against
+     * {@link getCacheNamesAsync}). Returns the {@link CacheClearResult}, or `null`
+     * when no cache by that name is registered (the server answers 404). A clear
+     * that runs but throws internally comes back as a result row with
+     * `succeeded: false` — that's distinct from the not-found `null`.
+     * SystemAdmin-gated.
+     */
+    clearCacheAsync(name: string, signal?: AbortSignal): Promise<CacheClearResult | null>;
     /**
      * Runs a FetchXML query and returns the matching records plus paging info.
      * The query is the FetchXML XML literal — the same format Dataverse natively accepts.
@@ -5767,23 +6512,24 @@ declare class PowerPortalsProClient {
      * client can render headers + dispatch cells without a separate
      * metadata round-trip.
      *
-     * Exactly one of <c>request.viewId</c> or <c>request.fetchXml</c> must
-     * be supplied; sending both or neither returns a 400.
+     * At least one of <c>request.viewId</c> or <c>request.fetchXml</c> must
+     * be supplied (neither returns a 400). Both may be supplied together — the
+     * <c>fetchXml</c> is the query and the <c>viewId</c> names the view for
+     * localized column-title resolution.
      *
-     * Mirrors how the Blazor `IGridService` is consumed —
+     * Mirrors how the is consumed
      * `@powerportalspro/react`'s `useGridData` hook calls this method
      * internally, so most consumers don't invoke it directly.
      */
     loadGridAsync(request: GridDataRequest, signal?: AbortSignal): Promise<GridDataResponse>;
     /**
-     * Updates an existing record. URL is derived from `record.tableName` and `record.id` —
+     * Updates an existing record. URL is derived from `record.tableName` and `record.id`
      * `record.id` must be set. For a new record, use {@link createRecordAsync} instead.
      */
     updateRecordAsync(record: TableRecord$1, signal?: AbortSignal): Promise<UpdateResponse>;
     /**
-     * Executes a batch of {@link OrganizationRequest}s as a single round-trip,
-     * matching Blazor's `IPowerPortalsProService.ExecuteMultipleAsync`. The
-     * MainContext save flow uses this to ship every dirty descendant's
+     * Executes a batch of {@link OrganizationRequest}s as a single round-trip.
+     * The MainContext save flow uses this to ship every dirty descendant's
      * requests in one shot so a multi-record save lands transactionally
      * server-side.
      *
@@ -5806,7 +6552,7 @@ declare class PowerPortalsProClient {
      * query, performs the multi-series pivot, and applies combined
      * date-label formatting using the request culture.
      *
-     * Mirrors how the Blazor `IChartService` is consumed —
+     * Mirrors how the is consumed
      * `@powerportalspro/react-charts`'s `DataverseChartDataSource` family
      * calls this method internally, so most consumers don't invoke it
      * directly.
@@ -5818,12 +6564,13 @@ declare class PowerPortalsProClient {
      * Returns the current user's combined table-level `TableSecurityPermission`
      * bitmask for `tableLogicalName` — the bitwise union of Read / Create /
      * Write / Delete / Append / AppendTo flags any registered
-     * `ITablePermissionHandler` allows for that user on that table. Mirrors
-     * the cached `ITablePermissionCache.GetPermissionForUserAsync` lookup
-     * Blazor's grid buttons already use directly via DI. Wrapped client-side
-     * by the `useTablePermissions(tableName)` React hook with in-flight-promise
-     * dedup; reach for the raw client only when you're outside React (e.g.
-     * a sample stand-alone script) or need an imperative one-off check.
+     * `ITablePermissionHandler` allows for that user on that table. Routed
+     * server-side through the cached `ITablePermissionCache` lookup.
+     *
+     * Wrapped by the `useTablePermissions(tableName)` React hook with
+     * in-flight-promise dedup; reach for the raw client only when you're
+     * outside React (e.g. a stand-alone script) or need an imperative
+     * one-off check.
      *
      * Returns `0` (`TableSecurityPermission.None`) when the user has no
      * permissions on the table; consumers compare via bit math (e.g.
@@ -5907,14 +6654,14 @@ declare class PowerPortalsProClient {
      * override files (last-wins). Use this to seed the React-side localizer
      * with one round-trip.
      *
-     * Returned shape is a nested object that mirrors the source JSON files —
+     * Returned shape is a nested object that mirrors the source JSON files
      * `{ app: { buttons: { save: { label: "Save" } } }, tables: { contact: ... } }`.
      * The client typically flattens this to dotted-key form for `t()` lookup
      * (see {@link flattenStrings} in `@powerportalspro/react`).
      *
      * @param culture culture code matching what server-side ASP.NET request
-     *   localization recognizes — e.g. `"en"`, `"es"`, `"fr-CA"`. Falls back
-     *   to the default culture server-side when the value isn't supported.
+     * localization recognizes — e.g. `"en"`, `"es"`, `"fr-CA"`. Falls back
+     * to the default culture server-side when the value isn't supported.
      */
     retrieveLocalizedStringsAsync(culture: string, signal?: AbortSignal): Promise<Record<string, unknown>>;
     /**
@@ -5939,12 +6686,12 @@ declare class PowerPortalsProClient {
      * Two response shapes, selected by `request.responseFormat`:
      *
      * - **BinaryStream** (default): the server returns the raw archive bytes; this
-     *   method reads them via `response.arrayBuffer()` and wraps the result in a
-     *   {@link FileArchiveResult}, deriving `fileName` from the `Content-Disposition`
-     *   header and `contentType` from `Content-Type`. Most consumers want this path.
+     * method reads them via `response.arrayBuffer()` and wraps the result in a
+     * {@link FileArchiveResult}, deriving `fileName` from the `Content-Disposition`
+     * header and `contentType` from `Content-Type`. Most consumers want this path.
      * - **Json**: the server returns a {@link FileArchiveJsonResponse} envelope with
-     *   the archive bytes base64-encoded. Useful for test harnesses, service workers,
-     *   or callers that need to inspect filename/size before triggering a download.
+     * the archive bytes base64-encoded. Useful for test harnesses, service workers,
+     * or callers that need to inspect filename/size before triggering a download.
      *
      * Either way, the returned `data` is empty (`Uint8Array(0)`) when none of the
      * supplied records produced a usable file — the caller can surface a "nothing to
@@ -5956,7 +6703,21 @@ declare class PowerPortalsProClient {
      * upload size in KB). UI consumers use this to validate uploads client-side before
      * the round-trip, mirroring what the server enforces.
      */
-    getEnvironmentFileSettingsAsync(signal?: AbortSignal): Promise<EnvironmentFileSettings>;
+    /**
+     * Reads the org-wide settings sourced from the Dataverse `organization`
+     * record: default currency plus file-upload constraints
+     * (`blockedFileExtensions`, `maxUploadFileSizeInBytes`). Replaces the legacy
+     * `getEnvironmentFileSettingsAsync` — file fields now live on this combined
+     * response.
+     * <para>
+     * Primary consumers:
+     * </para>
+     * - Create-mode `<MoneyEdit>` reads `defaultCurrency` to render the right
+     * symbol on brand-new records before save.
+     * - File editors / FileGrid read the two file fields to reject invalid
+     * uploads client-side before the round-trip.
+     */
+    getOrganizationSettingsAsync(signal?: AbortSignal): Promise<OrganizationSettings>;
 }
 
 type TableRecord = components['schemas']['TableRecord'];
@@ -5971,7 +6732,7 @@ type TableRecord = components['schemas']['TableRecord'];
  * Returns `undefined` when neither field carries a usable value (record
  * still loading, or a never-seeded create-mode record).
  *
- * Mirrors Blazor's `TableRecord -> TableRecordReference` implicit conversion
+ * Mirrors implicit conversion
  * (`Id == Guid.Empty ? _idForCreate : Id`). The server resolves either
  * shape via `ResolveAssociateRecordAsync` — both flows interoperate.
  */
@@ -5979,4 +6740,4 @@ declare function getRecordReferenceId(record: Pick<TableRecord, 'id' | '_idForCr
 
 declare const VERSION = "0.1.0";
 
-export { type AggregateChartConfig, AggregateType, ArchiveFormat, ArgumentError, ArgumentNullError, type AssociateRequest, AuthClient, type AuthenticatorSetupResponse, type BaseDataPoint, type ChangeEmailRequest, type ChangeEmailResponse, ChangeEmailResult, type ChangePasswordRequest, type ChangePasswordResponse, ChangePasswordResult, type ChartAggregation, type ChartData, type ChartDataRequest, type ChartDataResponse, type ChartDataset, ChartDateGrouping, type ChartGrouping, type ChartLinkedEntity, type ColumnSort, ColumnType, type ConfirmEmailRequest, type ConfirmEmailResponse, type ConfirmExternalLoginRequest, type ConfirmExternalLoginResponse, ConfirmExternalLoginResult, type CreateRequest, type CreateResponse, type CurrentLoginInfo, type CurrentUserInfo, type DataPoint, type DataverseDataPoint, DateTimeBehavior, type DeletePersonalDataRequest, type DeletePersonalDataResponse, DeletePersonalDataResult, type DeleteRequest, type DeleteResponse, type Disable2faResponse, type DisassociateRequest, type EnvironmentFileSettings, ExternalLoginCandidateKind, type ExternalLoginProviderInfo, type ExternalLoginsResponse, FileArchiveResponseFormat, type FileInfo, type Forget2faResponse, type GridDataRequest, type GridDataResponse, type GridFilterBase, InvalidOperationError, JoinOperator, type LoginRequest, type LoginResponse, LoginResult, type OrganizationRequest, type OrganizationResponse, type PendingExternalLoginResponse, type PersonalDataResponse, PowerPortalsProClient, PowerPortalsProError, type PowerPortalsProErrorInit, type ProblemDetails, type ProfileResponse, type RecoveryCodesResponse, type RegisterRequest, type RegisterResponse, RegisterResult, type RelationshipFilter, RelationshipFilterMode, type RemoveExternalLoginRequest, type RemoveExternalLoginResponse, type RequestOptions, type RequestPasswordResetRequest, RequiredLevel, type ResendEmailConfirmationRequest, type ResetAuthenticatorResponse, type ResetPasswordRequest, type ResetPasswordResponse, ResetPasswordResult, type ResolvedColumn, type RetrieveRecordsResponse, Routes, type SelectExternalLoginRequest, type SendEmailConfirmationResponse, type SetPasswordRequest, type SetPasswordResponse, type SwitchIdentityResponse, SwitchIdentityResult, type TableMetadata, type TableRecord$1 as TableRecord, type TableRecordReference, TableSecurityPermission, Transport, type TransportOptions, type TwoFactorStatusResponse, UnauthorizedAccessError, type UpdateProfileRequest, type UpdateRequest, type UpdateResponse, VERSION, type VerifyAuthenticatorRequest, type VerifyAuthenticatorResponse, type VerifyTwoFactorRequest, type VerifyTwoFactorResponse, type ViewMetadata, type components, getRecordReferenceId, mapProblemDetails, type paths };
+export { type AggregateChartConfig, AggregateType, ArchiveFormat, ArgumentError, ArgumentNullError, type AssociateRequest, AuthClient, type AuthOptionsResponse, type AuthenticatorSetupResponse, type BaseDataPoint, type CacheClearResult, type ChangeEmailRequest, type ChangeEmailResponse, ChangeEmailResult, type ChangePasswordRequest, type ChangePasswordResponse, ChangePasswordResult, type ChartAggregation, type ChartData, type ChartDataRequest, type ChartDataResponse, type ChartDataset, ChartDateGrouping, type ChartGrouping, type ChartLinkedEntity, type ColumnSort, ColumnType, type ConfirmEmailRequest, type ConfirmEmailResponse, type ConfirmExternalLoginRequest, type ConfirmExternalLoginResponse, ConfirmExternalLoginResult, type CreateRequest, type CreateResponse, type Currency, type CurrentLoginInfo, type CurrentUserInfo, type DataPoint, type DataverseDataPoint, DateTimeBehavior, type DeletePersonalDataRequest, type DeletePersonalDataResponse, DeletePersonalDataResult, type DeleteRequest, type DeleteResponse, type Disable2faResponse, type DisassociateRequest, ExternalLoginCandidateKind, type ExternalLoginProviderInfo, type ExternalLoginsResponse, FileArchiveResponseFormat, type FileInfo, type Forget2faResponse, type GridDataRequest, type GridDataResponse, type GridFilterBase, InvalidOperationError, JoinOperator, type LocalizationFileDownload, type LocalizationOverview, type LocalizationPipelineConfiguration, type LocalizationSourceKind, type LocalizationSourceLoad, type LocalizationSourceStatus, type LoginRequest, type LoginResponse, LoginResult, type OrganizationRequest, type OrganizationResponse, type OrganizationSettings, type PendingExternalLoginResponse, type PersonalDataResponse, PowerPortalsProClient, PowerPortalsProError, type PowerPortalsProErrorInit, type ProblemDetails, type ProfileResponse, type RecoveryCodesResponse, type RegisterRequest, type RegisterResponse, RegisterResult, type RelationshipFilter, RelationshipFilterMode, type RemoveExternalLoginRequest, type RemoveExternalLoginResponse, type RequestOptions, type RequestPasswordResetRequest, RequiredLevel, type ResendEmailConfirmationRequest, type ResetAuthenticatorResponse, type ResetPasswordRequest, type ResetPasswordResponse, ResetPasswordResult, type ResolvedColumn, type RetrieveRecordsResponse, Routes, type SelectExternalLoginRequest, type SendEmailConfirmationResponse, type SetPasswordRequest, type SetPasswordResponse, type SwitchIdentityResponse, SwitchIdentityResult, type TableMetadata, type TableRecord$1 as TableRecord, type TableRecordReference, TableSecurityPermission, type TranslatedFile, type TranslationAvailability, type TranslationLanguageOption, type TranslationRequest, type TranslationResult, Transport, type TransportOptions, type TwoFactorStatusResponse, UnauthorizedAccessError, type UpdateProfileRequest, type UpdateRequest, type UpdateResponse, VERSION, type VerifyAuthenticatorRequest, type VerifyAuthenticatorResponse, type VerifyTwoFactorRequest, type VerifyTwoFactorResponse, type ViewMetadata, type components, getRecordReferenceId, mapProblemDetails, type paths };