@powerportalspro/react 5.0.0-beta.2 → 5.0.0

package/dist/index.d.ts

@@ -1,12 +1,159 @@
 import * as react from 'react';
-import { ReactNode } from 'react';
+import { ChangeEvent, ReactNode } from 'react';
 import { components, TableMetadata as TableMetadata$1, ViewMetadata, CurrentUserInfo, Transport, AuthClient, PowerPortalsProClient, LoginRequest, LoginResponse, SwitchIdentityResponse, PowerPortalsProError, TableRecord, RetrieveRecordsResponse, GridDataRequest, GridDataResponse, GridFilterBase, ChartAggregation, ColumnSort, ResolvedColumn, TableSecurityPermission, ChartData, OrganizationRequest } from '@powerportalspro/core';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
-type EnvironmentFileSettings$2 = components['schemas']['EnvironmentFileSettings'];
 /**
- * Client-side cache for table metadata. Mirrors Blazor's
- * `ITableMetadataCache` interface (in `PowerPortalsPro.Common.Services`).
+ * Masking strategy applied to a masked text field.
+ *
+ * Hybrid const-object + literal-union — same pattern other enums in
+ * the package follow (e.g. `GridButtonBehavior`).
+ */
+declare const MaskMode: {
+    /** No masking — value passes through unchanged. */
+    readonly None: "none";
+    /**
+     * Per-character allow filter. Characters that don't match
+     * {@link MaskOptions.allowedPattern} are dropped as they're typed or pasted.
+     */
+    readonly Regex: "regex";
+    /**
+     * Slotted template (see {@link MaskOptions.pattern}) such as `(000) 000-0000`.
+     * `0` = digit, `A` = letter, `*` = alphanumeric; every other character is a
+     * literal inserted automatically.
+     */
+    readonly Pattern: "pattern";
+    /**
+     * Live numeric grouping driven by {@link MaskOptions.numeric} — thousands
+     * separators, an optional decimal portion, and an optional leading sign.
+     */
+    readonly Numeric: "numeric";
+};
+type MaskMode = (typeof MaskMode)[keyof typeof MaskMode];
+/**
+ * Numeric masking options for {@link MaskMode.Numeric}. All separators are
+ * supplied by the caller so the field stays culture-correct (a German consumer
+ * gets `.` groups and `,` decimals).
+ */
+interface NumericOptions {
+    /** Character used to separate the whole and fractional parts (e.g. `.`). */
+    decimalSeparator: string;
+    /** Character inserted between thousands groups (e.g. `,`). Empty disables grouping. */
+    groupSeparator: string;
+    /** Whether a single leading minus sign is accepted. */
+    allowNegative: boolean;
+    /** Maximum fractional digits, or `null` for unlimited. */
+    maxDecimals: number | null;
+    /** Whether a decimal portion is allowed at all (integers set this false). */
+    allowDecimal: boolean;
+}
+/** Configuration for a single reformat call. */
+interface MaskOptions {
+    mode: MaskMode;
+    /** Regex mode: a per-character allow test, e.g. `[0-9.]`. Chars failing it are dropped. */
+    allowedPattern: string | null;
+    /**
+     * Pattern mode: a slotted template, e.g. `(000) 000-0000`. `0`=digit, `A`=letter,
+     * `*`=alphanumeric; every other character is a literal inserted automatically.
+     */
+    pattern: string | null;
+    /** Numeric mode: separators, sign, decimal options. */
+    numeric: NumericOptions | null;
+    /**
+     * When true, the value reported by the consumer's `onValueChange` is the
+     * masked display string (with literals/separators included); when false, the
+     * unmasked logical value (e.g. `5551234567` rather than `(555) 123-4567`).
+     * Round-trips correctly either way because reformat is idempotent.
+     */
+    valueIncludesMask: boolean;
+}
+/** Output of a single reformat call. */
+interface ReformatResult {
+    /** The string to display in the input (masked / grouped). */
+    display: string;
+    /**
+     * The logical value reported back to the consumer (group separators stripped
+     * for numeric; mask literals stripped for pattern). Drives the bound model.
+     */
+    raw: string;
+    /** Caret offset into `display` after reformatting. */
+    caret: number;
+}
+/**
+ * Reformat `value` according to `options`. Pure — same input always yields the
+ * same `{ display, raw, caret }`. Caller is responsible for actually writing
+ * the new display string into the input and calling `setSelectionRange(caret,
+ * caret)`. {@link useMaskedTextField} does that wiring for React consumers.
+ */
+declare function reformat(value: string, caret: number, options: MaskOptions): ReformatResult;
+
+interface UseMaskedTextFieldOptions {
+    /**
+     * Current logical value (unmasked, the way it should be stored on the
+     * bound model). The hook reformats this into the masked `displayValue` it
+     * returns. Pass `null` / `undefined` for empty.
+     */
+    value: string | null | undefined;
+    /**
+     * Fires on every keystroke that changes the reported value. Receives the
+     * unmasked logical value (e.g. `5551234567`) when {@link valueIncludesMask}
+     * is `false`, the masked display string (e.g. `(555) 123-4567`) when `true`.
+     */
+    onValueChange: (raw: string | null) => void;
+    /** Masking strategy. Defaults to {@link MaskMode.None}. */
+    mode?: MaskMode | undefined;
+    /** Slotted template for {@link MaskMode.Pattern} (e.g. `(000) 000-0000`). */
+    pattern?: string | null | undefined;
+    /** Per-character allow regex for {@link MaskMode.Regex} (e.g. `[A-Za-z]`). */
+    allowedPattern?: string | null | undefined;
+    /** Numeric options for {@link MaskMode.Numeric}. */
+    numeric?: NumericOptions | null | undefined;
+    /**
+     * When `true`, the value reported by `onValueChange` is the masked display
+     * string (with literals/separators); when `false` (default), the unmasked
+     * logical value. Either form round-trips correctly because reformat is
+     * idempotent.
+     */
+    valueIncludesMask?: boolean | undefined;
+}
+interface UseMaskedTextFieldReturn {
+    /**
+     * Masked display string. Pass this to the consumer input's `value` prop
+     * the hook re-renders it via React state on every keystroke + external
+     * value push.
+     */
+    displayValue: string;
+    /**
+     * Input change handler — matches Fluent v9 `<Input onChange>`'s
+     * `(event, data: { value })` shape. Reformats the typed value, updates
+     * `displayValue`, and reports the logical value via `onValueChange`.
+     */
+    onChange: (event: ChangeEvent<HTMLInputElement>, data: {
+        value: string;
+    }) => void;
+    /**
+     * Callback ref — attach to the underlying `<input>`. The hook needs the
+     * element reference both for caret-position bookkeeping and for the
+     * focus / blur listeners that gate external value pushes.
+     */
+    inputRef: (el: HTMLInputElement | null) => void;
+    /**
+     * Push a value into the field even while it has focus, parking the caret
+     * at the end. Used by an owning editor's spinner / stepper controls.
+     */
+    forceValue: (value: string | null) => void;
+}
+/**
+ * React hook that wires caret-safe masking onto a controlled input. Returns
+ * `displayValue` + `onChange` to spread onto a Fluent v9 `<Input>` (or any
+ * controlled `<input>`), plus an `inputRef` callback to attach to the
+ * underlying element and an imperative `forceValue` helper.
+ */
+declare function useMaskedTextField(opts: UseMaskedTextFieldOptions): UseMaskedTextFieldReturn;
+
+type OrganizationSettings$2 = components['schemas']['OrganizationSettings'];
+/**
+ * Client-side cache for table metadata.
  *
  * The default implementation lives in-memory (Map) with in-flight-promise
  * dedup so N parallel `getAsync` calls for the same table share one
@@ -16,7 +163,7 @@ type EnvironmentFileSettings$2 = components['schemas']['EnvironmentFileSettings'
  *
  * Why this exists: the inline-editable grid mounts one `<RecordContext>`
  * per visible row when the user toggles edit mode on. Each RC would
- * otherwise fire its own `retrieveTableMetadataAsync` round-trip —
+ * otherwise fire its own `retrieveTableMetadataAsync` round-trip
  * thundering-herd against the same endpoint that produces visibly
  * staggered row rendering as each fetch's response lands. The cache
  * collapses that to a single fetch shared across all consumers.
@@ -40,7 +187,7 @@ interface TableMetadataCache {
 }
 /**
  * Client-side cache for Dataverse view metadata. Same shape and
- * rationale as {@link TableMetadataCache} — mirrors Blazor's
+ * rationale as {@link TableMetadataCache}
  * `IViewMetadataCache` (in `PowerPortalsPro.Common.Services`).
  *
  * Keyed by view id (Dataverse GUID, hyphenated, no braces). The default
@@ -83,23 +230,33 @@ interface ViewsForTableCache {
     clear(): void;
 }
 /**
- * Singleton cache for the org-wide environment file settings (blocked
- * extensions, max upload size). Unlike the keyed caches, there's only
- * one `EnvironmentFileSettings` per environment — no key parameter.
+ * Singleton cache for the org-wide settings sourced from the Dataverse
+ * `organization` record — default currency plus file-upload constraints.
+ * There's only one `OrganizationSettings` per environment, so no key
+ * parameter.
+ *
+ * Two distinct consumer classes share it:
+ * - Create-mode `<MoneyEdit>` reads `defaultCurrency` so the right symbol
+ * renders on brand-new records before save.
+ * - File editors (`<FileEdit>`, `<ImageEdit>`, `<FileGrid>`) read
+ * `blockedFileExtensions` + `maxUploadFileSizeInBytes` to reject invalid
+ * uploads client-side before the round-trip.
  *
- * Avoids the case where multiple `<FileGrid>`s on the same page each
- * fire their own `getEnvironmentFileSettingsAsync` request. The server
- * already caches the response, but the client-side cache eliminates
- * the duplicate HTTP round-trips entirely.
+ * Without the cache, every create-mode `<RecordContext>` mount AND every
+ * `<FileGrid>` would fire its own GET — multi-form pages and react-router
+ * navigations would generate redundant traffic even though the value is
+ * stable for the user's whole session. The server already caches the
+ * response; this cache eliminates the HTTP trips entirely.
+ *
+ * Replaces the legacy `EnvironmentFileSettingsCache`.
  */
-interface EnvironmentFileSettingsCache {
+interface OrganizationSettingsCache {
     /**
      * Returns the cached settings, fetching from the server on a miss.
      * Concurrent calls share a single in-flight promise. Returns `null`
-     * only when the server explicitly returns no settings (rare —
-     * typically the endpoint always returns a value).
+     * only when the server explicitly returns no settings.
      */
-    getAsync(): Promise<EnvironmentFileSettings$2 | null>;
+    getAsync(): Promise<OrganizationSettings$2 | null>;
     /**
      * Drops the cached value. The next `getAsync` re-fetches from the
      * server.
@@ -128,7 +285,7 @@ type AuthStatus = (typeof AuthStatus)[keyof typeof AuthStatus];
  * either `anonymous` or `authenticated` for the rest of the app's lifetime (until
  * `login()` / `logout()` actions transition it).
  *
- * The `authenticated` branch carries the {@link CurrentUserInfo} the server returned —
+ * The `authenticated` branch carries the {@link CurrentUserInfo} the server returned
  * the auto-generated DTO from `@powerportalspro/core`, no narrowing applied. Fields
  * like `roles` arrive as `string[] | undefined` per the wire contract; consumers
  * coalesce to `[]` at the read site if they want a non-null array.
@@ -165,11 +322,10 @@ interface PowerPortalsProContextValue {
      */
     readonly viewsForTableCache: ViewsForTableCache;
     /**
-     * Client-side cache for the singleton environment file settings
-     * (blocked extensions, max upload size). See
-     * {@link EnvironmentFileSettingsCache}.
+     * Client-side cache for the singleton organization settings (default
+     * currency plus file-upload constraints). See {@link OrganizationSettingsCache}.
      */
-    readonly environmentFileSettingsCache: EnvironmentFileSettingsCache;
+    readonly organizationSettingsCache: OrganizationSettingsCache;
     /** Current auth state. {@link useAuth} unpacks this directly. */
     readonly authState: AuthState;
     /** Refreshes the auth state by re-calling `/api/auth/me`. */
@@ -195,7 +351,7 @@ interface PowerPortalsProProviderProps {
     /**
      * Optional pre-constructed {@link Transport} for the AuthClient and PowerPortalsProClient
      * to share. Pass one to set a non-default `baseUrl`, inject a custom `fetch`
-     * implementation for tests, etc. When omitted, a default transport is constructed —
+     * implementation for tests, etc. When omitted, a default transport is constructed
      * same-origin, browser fetch, cookie credentials included.
      *
      * The provider holds a stable reference to the transport for its lifetime — passing
@@ -254,10 +410,10 @@ interface PowerPortalsProProviderProps {
      */
     viewsForTableCache?: ViewsForTableCache;
     /**
-     * Custom {@link EnvironmentFileSettingsCache} implementation. Same
+     * Custom {@link OrganizationSettingsCache} implementation. Same
      * defaulting behavior as {@link tableMetadataCache}.
      */
-    environmentFileSettingsCache?: EnvironmentFileSettingsCache;
+    organizationSettingsCache?: OrganizationSettingsCache;
 }
 /**
  * Top-level provider for `@powerportalspro/react`. Constructs an {@link AuthClient}
@@ -268,14 +424,14 @@ interface PowerPortalsProProviderProps {
  * Wrap the app once near the root:
  * ```tsx
  * <PowerPortalsProProvider>
- *   <App />
+ * <App />
  * </PowerPortalsProProvider>
  * ```
  *
  * Hooks ({@link useAuth}, {@link usePowerPortalsPro}, {@link useRecord}, …) read from
  * this provider's context.
  */
-declare function PowerPortalsProProvider({ children, transport, localizationUrl, localizationUrls, localizationPrefixes, tableMetadataCache, viewMetadataCache, viewsForTableCache, environmentFileSettingsCache, }: PowerPortalsProProviderProps): react_jsx_runtime.JSX.Element;
+declare function PowerPortalsProProvider({ children, transport, localizationUrl, localizationUrls, localizationPrefixes, tableMetadataCache, viewMetadataCache, viewsForTableCache, organizationSettingsCache, }: PowerPortalsProProviderProps): react_jsx_runtime.JSX.Element;
 
 /**
  * Returns the {@link AuthClient}, {@link PowerPortalsProClient}, and underlying
@@ -296,8 +452,8 @@ declare function usePowerPortalsPro(): PowerPortalsProContextValue;
  * import { AuthStatus, useAuth } from '@powerportalspro/react';
  *
  * const auth = useAuth();
- * if (auth.status === AuthStatus.Loading)       return <Spinner />;
- * if (auth.status === AuthStatus.Anonymous)     return <SignInButton onClick={() => auth.login(...)} />;
+ * if (auth.status === AuthStatus.Loading) return <Spinner />;
+ * if (auth.status === AuthStatus.Anonymous) return <SignInButton onClick={() => auth.login(...)} />;
  * if (auth.status === AuthStatus.Authenticated) return <span>Hi, {auth.user.email}</span>;
  * ```
  *
@@ -305,7 +461,7 @@ declare function usePowerPortalsPro(): PowerPortalsProContextValue;
  * propagates via context, so all `useAuth` calls in the tree see the same value
  * and re-render on transitions.
  *
- * `login` mirrors {@link AuthClient.loginAsync} — same request/response shapes —
+ * `login` mirrors {@link AuthClient.loginAsync} — same request/response shapes
  * but additionally re-fetches `/api/auth/me` on `Success` so the auth state
  * transitions to `authenticated` without an extra round-trip from the consumer.
  *
@@ -337,11 +493,11 @@ interface AuthorizedViewProps {
     children: ReactNode;
     /**
      * Optional role gate. When supplied, the principal must hold AT LEAST ONE of
-     * the listed roles for the children to render — matching Blazor's
+     * the listed roles for the children to render
      * `<AuthorizeView Roles="Admin,Manager">` (comma-separated = OR).
      *
      * Roles arrive on `auth.user.roles` from `/api/auth/me`. Per-role claims are
-     * only emitted for systemuser-backed principals — contacts don't have roles —
+     * only emitted for systemuser-backed principals — contacts don't have roles
      * so a role gate also implicitly limits the surface to staff users.
      */
     roles?: string | readonly string[];
@@ -352,7 +508,7 @@ interface AuthorizedViewProps {
     fallback?: ReactNode;
 }
 /**
- * Headless auth gate — React equivalent of Blazor's `<AuthorizeView>`. Renders
+ * Headless auth gate — Renders
  * {@link AuthorizedViewProps.children} only when the principal is authenticated;
  * if {@link AuthorizedViewProps.roles} is supplied, the principal must hold at
  * least one of the listed roles. Otherwise renders {@link AuthorizedViewProps.fallback}
@@ -365,15 +521,15 @@ interface AuthorizedViewProps {
  * @example
  * ```tsx
  * <AuthorizedView>
- *   <Link to="/Account/Manage">Manage account</Link>
+ * <Link to="/Account/Manage">Manage account</Link>
  * </AuthorizedView>
  *
  * <AuthorizedView roles="SystemAdmin">
- *   <Link to="/SiteAdmin">Site admin</Link>
+ * <Link to="/SiteAdmin">Site admin</Link>
  * </AuthorizedView>
  *
  * <AuthorizedView roles={["Admin", "Manager"]} fallback={<span>Restricted</span>}>
- *   <SensitiveTools />
+ * <SensitiveTools />
  * </AuthorizedView>
  * ```
  */
@@ -469,7 +625,7 @@ interface UseFetchRecordsOptions {
 }
 /**
  * Runs a FetchXML query. Re-runs when the `fetchXml` string changes; aborts
- * in-flight requests on unmount. The query string is the FetchXML XML literal —
+ * in-flight requests on unmount. The query string is the FetchXML XML literal
  * the same format Dataverse natively accepts.
  *
  * `data.records` is the matched record list; `data.pagingCookie` and friends drive
@@ -495,10 +651,9 @@ interface UseGridDataOptions {
 }
 /**
  * Grid-data counterpart to {@link useFetchRecords}. Calls the server's
- * `POST /api/grids/data` endpoint, which composes the final FetchXML via the
- * shared `IFetchXmlQueryComposer` — applying search across the view's
- * searchable columns, replacing sorts, AND-merging filters, etc. — so the
- * search / sort / paging semantics match the Blazor grid exactly.
+ * `POST /api/grids/data` endpoint, which composes the final FetchXML via
+ * the shared `IFetchXmlQueryComposer` — applying search across the view's
+ * searchable columns, replacing sorts, AND-merging filters, etc.
  *
  * Response includes both the row data (`tableRecords`, `pagingInfo`) and a
  * server-resolved `columns` array — display names already localized, types
@@ -509,8 +664,10 @@ interface UseGridDataOptions {
  * serialization — cheap, and the request is a small flat object). Aborts
  * in-flight requests on unmount or when the request changes.
  *
- * Exactly one of `request.viewId` or `request.fetchXml` must be supplied;
- * sending both or neither produces a 400 from the server.
+ * At least one of `request.viewId` or `request.fetchXml` must be supplied
+ * (neither produces a 400 from the server). Both may be supplied together —
+ * the `fetchXml` is the query and the `viewId` names the view for localized
+ * column-title resolution.
  */
 declare function useGridData(request: GridDataRequest, options?: UseGridDataOptions): QueryResult<GridDataResponse>;
 
@@ -532,12 +689,12 @@ interface ViewDataSourceHighlight {
  * Options accepted by {@link useViewDataSource}. Split into two roles:
  *
  * - **Props** (forwarded straight into every request) — `viewId` /
- *   `fetchXml` source, `staticFilters` (always-applied, never cleared
- *   by mutators — the SubGrid relationship-filter case), `aggregations`
- *   spec, behavior knobs (`enabled`, `keepPreviousData`, `debounceMs`).
- * - **Initial state** (seeds once on mount, mutators take over) —
- *   `initialFilter`, `initialSort`, `initialSearch`, `initialPage`,
- *   `initialPageSize`, `initialHighlight`.
+ * `fetchXml` source, `staticFilters` (always-applied, never cleared
+ * by mutators — the SubGrid relationship-filter case), `aggregations`
+ * spec, behavior knobs (`enabled`, `keepPreviousData`, `debounceMs`).
+ * - **Initial state** (seeds once on mount, mutators take over)
+ * `initialFilter`, `initialSort`, `initialSearch`, `initialPage`,
+ * `initialPageSize`, `initialHighlight`.
  *
  * The same datasource instance feeds a `<MainGrid>` and a
  * `<DataverseChart>` (or two of either) — they all read the same row
@@ -546,14 +703,16 @@ interface ViewDataSourceHighlight {
  */
 interface UseViewDataSourceOptions {
     /**
-     * Stored Dataverse view to query. Mutually exclusive with
-     * {@link fetchXml}. Reading the view's columns drives the
-     * search-column-type dispatch.
+     * Stored Dataverse view to query. When set alongside {@link fetchXml},
+     * the FetchXML drives the query and this id only supplies the view's
+     * identity for view-specific localized column titles (no savedquery is
+     * loaded). At least one of {@link viewId} / {@link fetchXml} must be set.
      */
     viewId?: string;
     /**
-     * Caller-supplied FetchXML to query. Mutually exclusive with
-     * {@link viewId}. Useful for custom views.
+     * Caller-supplied FetchXML to query. Useful for custom (in-memory) views.
+     * May be combined with {@link viewId} to give such a view a stable
+     * identity for localization (see its docs).
      */
     fetchXml?: string;
     /**
@@ -699,20 +858,20 @@ interface ViewDataSource {
  *
  * ```tsx
  * function OpportunitiesPage() {
- *   const ds = useViewDataSource({
- *     viewId: openOpportunitiesViewId,
- *     aggregations: [
- *       { groupBy: { column: 'stepname' },
- *         aggregateColumn: 'estimatedvalue',
- *         aggregate: AggregateType.Sum },
- *     ],
- *   });
- *   return (
- *     <>
- *       <DataverseChart dataSource={ds} type="bar" />
- *       <MainGrid dataSource={ds} />
- *     </>
- *   );
+ * const ds = useViewDataSource({
+ * viewId: openOpportunitiesViewId,
+ * aggregations: [
+ * { groupBy: { column: 'stepname' },
+ * aggregateColumn: 'estimatedvalue',
+ * aggregate: AggregateType.Sum },
+ * ],
+ * });
+ * return (
+ * <>
+ * <DataverseChart dataSource={ds} type="bar" />
+ * <MainGrid dataSource={ds} />
+ * </>
+ * );
  * }
  * ```
  */
@@ -742,11 +901,9 @@ interface UseTablePermissionsOptions {
 }
 /**
  * Fetches the current user's combined table-level `TableSecurityPermission`
- * mask for one Dataverse table. Mirrors the server-side
- * `ITablePermissionCache.GetPermissionForUserAsync` lookup the Blazor
- * grid buttons already use directly via DI — exposed here so React
- * consumers can drive the same "Can the user create / delete on this
- * table?" gates without firing a grid query.
+ * mask for one Dataverse table — exposed so consumers can drive
+ * "Can the user create / delete on this table?" gates without firing a
+ * grid query.
  *
  * When a `<MainGrid>` / `<SubGrid>` is on the page the grid response
  * already carries the same value as `GridDataResponse.tablePermissions`
@@ -787,24 +944,25 @@ interface UseViewsForTableOptions {
  */
 declare function useViewsForTable(tableLogicalName: string, options?: UseViewsForTableOptions): QueryResult<readonly ViewMetadata[]>;
 
-type EnvironmentFileSettings$1 = components['schemas']['EnvironmentFileSettings'];
-interface UseEnvironmentFileSettingsOptions {
+type OrganizationSettings$1 = components['schemas']['OrganizationSettings'];
+interface UseOrganizationSettingsOptions {
     enabled?: boolean;
 }
 /**
- * Fetches the environment-wide file upload settings (blocked extension
- * list, organization-level max upload size). Mirrors the Blazor
- * <c>IPowerPortalsProService.GetEnvironmentFileSettingsAsync</c> call.
+ * Fetches the org-wide settings (default currency, etc.) sourced from the
+ * Dataverse `organization` record.
  *
- * Routed through {@link EnvironmentFileSettingsCache} on the provider —
- * concurrent callers (e.g. multiple `<FileGrid>`s on the same page)
- * share a single fetch, and the resolved value is reused across re-
- * mounts for the lifetime of the `PowerPortalsProClient`. The cap
- * reported here is the org-wide ceiling — the effective per-upload cap
- * also has to account for per-column <c>maxSizeInKB</c> from
- * {@link useTableMetadata}.
+ * Routed through {@link OrganizationSettingsCache} on the provider
+ * concurrent callers (e.g. multiple create-mode `<RecordContext>`s on the
+ * same page) share a single fetch, and the resolved value is reused
+ * across re-mounts for the lifetime of the `PowerPortalsProClient`.
+ *
+ * Primary consumer is the create-mode `<RecordContext>` seed: the framework
+ * pre-fills `record.currency` with `defaultCurrency` so `<MoneyEdit>`
+ * renders the correct symbol on brand-new records before save. Custom
+ * components that need other org-level defaults can read them here too.
  */
-declare function useEnvironmentFileSettings(options?: UseEnvironmentFileSettingsOptions): QueryResult<EnvironmentFileSettings$1>;
+declare function useOrganizationSettings(options?: UseOrganizationSettingsOptions): QueryResult<OrganizationSettings$1>;
 
 interface UseSupportedLocalesOptions {
     /**
@@ -826,18 +984,16 @@ interface UseSupportedLocalesOptions {
  * request on every page navigation in apps where the dropdown sits
  * inside route-level chrome.
  *
- * Fallback path: when no `DefaultLocalizerProvider` is mounted (rare —
+ * Fallback path: when no `DefaultLocalizerProvider` is mounted (rare
  * consumers who wired their own i18next setup via
  * `localizationUrl={false}`), the hook still issues its own fetch so
  * the API works in isolation. The fallback uses the same
  * `useAsyncResource` shape it always did, so the {@link QueryResult}
  * surface is unchanged.
  *
- * The Blazor side gets this server-side via
- * `IOptions<RequestLocalizationOptions>.SupportedUICultures`; in
- * React the same configuration is exposed through the localization
- * manifest endpoint at `/localizations/version`. Order matches the
- * server's configured preference, default culture first.
+ * Server-side configuration is exposed through the localization manifest
+ * endpoint at `/localizations/version`. Order matches the server's
+ * configured preference, default culture first.
  */
 declare function useSupportedLocales(options?: UseSupportedLocalesOptions): QueryResult<readonly string[]>;
 
@@ -864,7 +1020,7 @@ declare function useSupportedLocales(options?: UseSupportedLocalesOptions): Quer
  */
 declare function useQueryParam(name: string): string | null;
 
-type EnvironmentFileSettings = components['schemas']['EnvironmentFileSettings'];
+type OrganizationSettings = components['schemas']['OrganizationSettings'];
 /**
  * Default in-memory implementation of {@link TableMetadataCache}. Wraps
  * a `PowerPortalsProClient.retrieveTableMetadataAsync` call with Map-based
@@ -890,19 +1046,19 @@ declare class InMemoryViewMetadataCache implements ViewMetadataCache {
     clear(): void;
 }
 /**
- * Default in-memory implementation of {@link EnvironmentFileSettingsCache}.
+ * Default in-memory implementation of {@link OrganizationSettingsCache}.
  * Singleton-shaped: no key, just one stored value + one in-flight promise.
  *
- * Implemented as a thin wrapper around the keyed {@link InMemoryCache}
- * with a fixed sentinel key, so the dedup / fetch / error-eviction
- * behaviors stay identical to the metadata caches without re-implementing
- * any of that logic.
+ * Implemented as a thin wrapper around the keyed {@link InMemoryCache} with
+ * a fixed sentinel key, so the dedup / fetch / error-eviction behaviors stay
+ * identical to the metadata caches without re-implementing any of that
+ * logic.
  */
-declare class InMemoryEnvironmentFileSettingsCache implements EnvironmentFileSettingsCache {
+declare class InMemoryOrganizationSettingsCache implements OrganizationSettingsCache {
     private static readonly KEY;
     private readonly cache;
     constructor(ppp: PowerPortalsProClient);
-    getAsync(): Promise<EnvironmentFileSettings | null>;
+    getAsync(): Promise<OrganizationSettings | null>;
     invalidate(): void;
 }
 /**
@@ -993,17 +1149,17 @@ interface MainContextValue {
      * Transactionally saves the entire descendant subtree:
      *
      * 1. Calls {@link MainContextProps.onBeforeSave} (if wired). Throwing
-     *    aborts the save before any server call.
+     * aborts the save before any server call.
      * 2. Runs {@link validate} across descendants; returns early without
-     *    saving when any descendant reports invalid.
+     * saving when any descendant reports invalid.
      * 3. Collects {@link MainContextDescendant.getRequests} from every
-     *    registered descendant.
+     * registered descendant.
      * 4. If non-empty, ships the combined array in one
-     *    `executeMultipleAsync` round-trip so the operations land
-     *    transactionally on the server.
+     * `executeMultipleAsync` round-trip so the operations land
+     * transactionally on the server.
      * 5. Calls {@link refreshAll} so the local state picks up server-applied
-     *    side-effects (computed columns, plugin defaults, the modifiedon
-     *    timestamp, etc.).
+     * side-effects (computed columns, plugin defaults, the modifiedon
+     * timestamp, etc.).
      *
      * Throws on the first server-side failure; later steps are skipped.
      */
@@ -1034,10 +1190,9 @@ interface MainContextValue {
      * append extra requests before calling
      * `IPowerPortalsPro.executeMultipleAsync` directly).
      *
-     * Mirrors Blazor's public `MainContext.GetRequests()` — same walk over
-     * registered grids / child contexts / M2M editors, same shape.
-     * Consumers that just want to save should call {@link saveAll}; this
-     * is the escape hatch for the rarer dry-run / merge-with-extras case.
+     * Walks the registered grids, child contexts, and M2M editors. Consumers
+     * that just want to save should call {@link saveAll}; this is the escape
+     * hatch for the rarer dry-run / merge-with-extras case.
      */
     readonly getRequests: () => OrganizationRequest[];
     /**
@@ -1100,10 +1255,10 @@ interface MainContextProps {
      * Resolution rules:
      * - `true` / `false` — explicit override at this level.
      * - `undefined` (default) — inherit from the parent
-     *   {@link MainContext} / {@link RecordContext}, falling back to `true` at
-     *   the root. Set `false` on the outer context of e.g. a demo site to
-     *   suppress the prompt across the whole subtree without touching every
-     *   nested context.
+     * {@link MainContext} / {@link RecordContext}, falling back to `true` at
+     * the root. Set `false` on the outer context of e.g. a demo site to
+     * suppress the prompt across the whole subtree without touching every
+     * nested context.
      *
      * Only the **top-most** MainContext / RecordContext on the page actually
      * registers the listener — when contexts nest, the inner ones skip
@@ -1126,8 +1281,8 @@ interface MainContextProps {
      * Resolution rules (same as {@link warnOnUnsavedChanges}):
      * - `true` / `false` — explicit override at this level.
      * - `undefined` (default) — inherit from the parent
-     *   {@link MainContext} / {@link RecordContext}, falling back to `true`
-     *   at the root.
+     * {@link MainContext} / {@link RecordContext}, falling back to `true`
+     * at the root.
      */
     forceSuccessfulValidationBeforeSave?: boolean;
 }
@@ -1142,14 +1297,12 @@ interface MainContextProps {
  * register with their nearest ancestor.
  *
  * Deferred surface (and how to layer it on later):
- * - **Dirty tracking.** Blazor's MainContext aggregates `isDirty` across children
- *   via `EditContext`. React doesn't have a built-in form layer; consumers bring
- *   their own (react-hook-form, formik, vanilla state). When the dirty story
- *   solidifies, an `isDirty: () => boolean` getter on `MainContextDescendant`
- *   plus an aggregate getter on `MainContextValue` is the natural extension.
+ * - **Dirty tracking.** Consumers bring their own form layer (react-hook-form,
+ * formik, vanilla state). When the dirty story solidifies in a project, an
+ * `isDirty: () => boolean` getter on `MainContextDescendant` plus an aggregate
+ * getter on `MainContextValue` is the natural extension.
  * - **Unsaved-changes warning** dialog on navigation. Driven by dirty tracking.
  * - **Validation orchestration**. Same — needs the form layer.
- * - **Persistent state across server↔WASM**. N/A in pure React.
  */
 declare function MainContext({ children, onBeforeSave, warnOnUnsavedChanges, forceSuccessfulValidationBeforeSave, }: MainContextProps): react_jsx_runtime.JSX.Element;
 /**
@@ -1162,12 +1315,11 @@ declare function useMainContext(): MainContextValue | null;
 /**
  * Provides an existing {@link MainContextValue} to a subtree. Used by
  * {@link RecordContext} to expose itself as a `MainContext` for nested
- * descendants (mirroring Blazor's `RecordContext : MainContext` inheritance) —
- * keeps the raw `MainContextContext` internal while still letting framework
- * components compose multiple `MainContext` levels.
+ * descendants — keeps the raw `MainContextContext` internal while still
+ * letting framework components compose multiple `MainContext` levels.
  *
- * Not generally needed by application code — use `<MainContext>` instead, which
- * builds the value internally.
+ * Not generally needed by application code — use `<MainContext>` instead,
+ * which builds the value internally.
  */
 declare function MainContextProvider({ value, children, }: {
     value: MainContextValue;
@@ -1210,11 +1362,10 @@ interface RecordContextValue {
      * (when dirty) followed by each nested descendant's `getRequests()`, in
      * registration order. Returns an empty array when nothing is dirty.
      *
-     * Mirrors Blazor's public `RecordContext.GetRequests()` — same shape, same
-     * traversal. Use for previewing the payload {@link save} would ship,
-     * for dry-run UIs, or to merge the records into a custom
-     * `executeMultiple` batch alongside consumer-supplied requests.
-     * Consumers that just want to persist should call {@link save}.
+     * Use for previewing the payload {@link save} would ship, for dry-run
+     * UIs, or to merge the records into a custom `executeMultiple` batch
+     * alongside consumer-supplied requests. Consumers that just want to
+     * persist should call {@link save}.
      */
     readonly getRequests: () => OrganizationRequest[];
     /**
@@ -1315,7 +1466,7 @@ interface RecordContextValue {
 }
 /**
  * `RecordContext` extends {@link MainContextProps} because every `RecordContext`
- * conceptually IS-A `MainContext` — Blazor's `RecordContext.razor.cs` literally
+ * conceptually IS-A `MainContext` — literally
  * inherits from `MainContext.razor.cs` and `override`s `IsDirty` to add the
  * record's own dirty state on top of the base aggregation. Inheriting the props
  * means `onBeforeSave` (and any future cross-cutting `MainContextProps`) is
@@ -1420,8 +1571,7 @@ interface RecordContextProps extends MainContextProps {
 }
 /**
  * Loads a single Dataverse record and provides it to descendants via React
- * context (the analog of Blazor's cascading value). Children call
- * {@link useRecordContext} to read the record + status.
+ * context. Children call {@link useRecordContext} to read the record + status.
  *
  * Also acts as a `MainContext` for its own subtree — nested grids, M2M editors,
  * and child `<RecordContext>`s register with this `RecordContext` instead of
@@ -1435,18 +1585,10 @@ interface RecordContextProps extends MainContextProps {
  * Without a parent, `save()` and `reload()` are still callable directly from
  * descendants via the context.
  *
- * What's deferred from Blazor's RecordContext (the full version is ~700 lines —
- * this is the headless coordination skeleton):
- * - **New-record creation** (id absent → empty TableRecord). Will need a
- *   `mode: "edit" | "create"` discriminator and dispatching `createRecordAsync`
- *   instead of `updateRecordAsync` from `save()`.
- * - **Dirty tracking + EditContext-style validation**. Tied to the form layer.
+ * Deferred surface (the headless coordination skeleton; rounded out later):
  * - **`OnBeforeSave` / `OnBeforeDelete`** cancellable callbacks at this level
- *   (MainContext already has `onBeforeSave`).
+ * (MainContext already exposes `onBeforeSave`).
  * - **Delete handler** with confirmation flow.
- * - **URL query-parameter reading** (Blazor's `QueryParameterName`). Consumers can
- *   pull the id from `useSearchParams()` themselves and pass it as the `id` prop.
- * - **PersistentComponentState** for server→WASM bridging. N/A in pure React.
  */
 /**
  * Wrapper that auto-mounts a {@link ValidationProvider} around the inner
@@ -1467,10 +1609,10 @@ declare function RecordContext(props: RecordContextProps): react_jsx_runtime.JSX
  * import { QueryStatus, useRecordContext } from '@powerportalspro/react';
  *
  * function ContactDetails() {
- *   const { status, record } = useRecordContext();
- *   if (status === QueryStatus.Loading) return <Spinner />;
- *   if (status === QueryStatus.Error)   return <ErrorBanner />;
- *   return <h1>{record!.formattedValues?.name}</h1>;
+ * const { status, record } = useRecordContext();
+ * if (status === QueryStatus.Loading) return <Spinner />;
+ * if (status === QueryStatus.Error) return <ErrorBanner />;
+ * return <h1>{record!.formattedValues?.name}</h1>;
  * }
  * ```
  */
@@ -1495,16 +1637,14 @@ interface LookupRecordContextProps {
      * `$type: 6`) — the component reads the lookup's `tableName` + `value`
      * and spawns a nested `<RecordContext>` for the referenced record.
      *
-     * Required. Mirrors Blazor's `<LookupRecordContext ColumnName="...">`
-     * `ColumnName` parameter.
+     * Required.
      */
     columnName: string;
     /**
      * Optional pre-save cancellable hook forwarded to the nested
      * `<RecordContext>`. Throwing (or returning a rejected promise) from
      * this callback aborts the save before any server call — the same
-     * semantic as `<RecordContext onBeforeSave={…}>` directly. Mirrors
-     * Blazor's `LookupRecordContext.OnBeforeSave` cancellable hook.
+     * semantic as `<RecordContext onBeforeSave={…}>` directly.
      */
     onBeforeSave?: () => void | Promise<void>;
     /**
@@ -1519,16 +1659,15 @@ interface LookupRecordContextProps {
     /**
      * When `false`, renders nothing. Defaults to `true`. Useful for
      * conditionally hiding the section without unmounting the
-     * declaration. Mirrors `IsVisible` on the other framework
-     * components.
+     * declaration.
      */
     isVisible?: boolean;
 }
 /**
  * Branches off into a nested `<RecordContext>` for the record referenced
- * by a lookup column on the surrounding `<RecordContext>`. Mirrors
- * Blazor's `<LookupRecordContext>` — a thin wrapper that resolves the
- * lookup value, gates on its presence, and spawns the nested context.
+ * by a lookup column on the surrounding `<RecordContext>`. A thin
+ * wrapper that resolves the lookup value, gates on its presence, and
+ * spawns the nested context.
  *
  * Edit components inside the lookup context bind to columns on the
  * LOOKED-UP record's table, not the parent's. Changes flow through the
@@ -1538,46 +1677,44 @@ interface LookupRecordContextProps {
  * `<RecordContext>`-as-MainContext) and its pending edits join the
  * single transactional `executeMultiple` batch on save.
  *
- * **Conditional render (matches Blazor's lazy pattern):** the nested
- * `<RecordContext>` is only instantiated when the lookup actually has
- * a value (non-null + non-empty-GUID + has `tableName`). Empty lookups
- * render nothing — avoids spinning up nested contexts, EditContext
- * validators, descendant registrations, etc. for every empty lookup
- * column on a form. The Blazor source carries an explicit perf note on
- * this: ~10 lookups × per-render lifecycle overhead added up to a
- * measurable freeze before the conditional render was added.
+ * **Conditional render:** the nested `<RecordContext>` is only
+ * instantiated when the lookup actually has a value (non-null +
+ * non-empty-GUID + has `tableName`). Empty lookups render nothing
+ * avoids spinning up nested contexts, EditContext validators,
+ * descendant registrations, etc. for every empty lookup column on a
+ * form. With ~10 lookups on a complex form, the per-render lifecycle
+ * overhead is large enough to produce a measurable freeze without this
+ * guard.
  *
  * ```tsx
  * <RecordContext table="account" id={accountId}>
- *   <Section>
- *     <SectionColumn header={<Text>Account</Text>}>
- *       <TextEdit columnName="name" />
- *       <TextEdit columnName="accountnumber" />
- *     </SectionColumn>
- *
- *     <SectionColumn header={<Text>Primary contact</Text>}>
- *       <LookupRecordContext columnName="primarycontactid">
- *         {/* These edits bind to the linked CONTACT, not the account *\/}
- *         <TextEdit columnName="firstname" />
- *         <TextEdit columnName="lastname" />
- *         <TextEdit columnName="emailaddress1" type="email" />
- *       </LookupRecordContext>
- *     </SectionColumn>
- *   </Section>
+ * <Section>
+ * <SectionColumn header={<Text>Account</Text>}>
+ * <TextEdit columnName="name" />
+ * <TextEdit columnName="accountnumber" />
+ * </SectionColumn>
+ *
+ * <SectionColumn header={<Text>Primary contact</Text>}>
+ * <LookupRecordContext columnName="primarycontactid">
+ * {/* These edits bind to the linked CONTACT, not the account *\/}
+ * <TextEdit columnName="firstname" />
+ * <TextEdit columnName="lastname" />
+ * <TextEdit columnName="emailaddress1" type="email" />
+ * </LookupRecordContext>
+ * </SectionColumn>
+ * </Section>
  * </RecordContext>
  * ```
  *
  * Renders `null` when:
- *  - the surrounding `<RecordContext>` hasn't loaded yet,
- *  - the parent column doesn't carry a `LookupValue`,
- *  - the lookup is the empty GUID (Dataverse's "no value" sentinel), or
- *  - the lookup is missing its `tableName`.
+ * - the surrounding `<RecordContext>` hasn't loaded yet,
+ * - the parent column doesn't carry a `LookupValue`,
+ * - the lookup is the empty GUID (Dataverse's "no value" sentinel), or
+ * - the lookup is missing its `tableName`.
  *
- * `<LookupRecordContext>` deliberately does NOT mirror Blazor's
- * `BaseColumnEdit` inheritance — the parent's column read-write loop
- * is owned by `useLookupColumn(columnName)` for consumers who want to
- * change the lookup value programmatically; `<LookupRecordContext>` is
- * pure read-then-branch.
+ * `<LookupRecordContext>` is read-then-branch only — consumers who want
+ * to change the lookup value programmatically use
+ * `useLookupColumn(columnName)` from the parent context instead.
  */
 declare function LookupRecordContext({ columnName, onBeforeSave, children, isVisible, }: LookupRecordContextProps): react_jsx_runtime.JSX.Element | null;
 
@@ -1590,10 +1727,9 @@ type ColumnMetadataBase = components['schemas']['ColumnMetadataBase'];
  * - the column doesn't exist on the table.
  *
  * Edit components use this to auto-resolve defaults (`maxLength`, `min`,
- * `max`, `precision`, `required`, `readOnly`) when consumer-passed props are
- * absent. Pass-through props always win — same convention as Blazor's
- * `BaseColumnEdit.OnParametersSetAsync` (which only fills metadata-derived
- * defaults when the consumer hasn't set them explicitly).
+ * `max`, `precision`, `required`, `readOnly`) when consumer-passed props
+ * are absent. Pass-through props always win — metadata-derived defaults
+ * only fill the slots the consumer left unset.
  *
  * Throws if not used inside a `<RecordContext>`, since column metadata only
  * makes sense relative to a record's table.
@@ -1608,7 +1744,7 @@ declare function useColumnMetadata(columnName: string): ColumnMetadataBase | und
  * map for tests, or a server-driven RPC localizer all work the same way.
  *
  * Args use positional indexing (`args[0]` → `{0}` in the template) to match
- * the existing Blazor `IStringLocalizer` JSON format — `.NET String.Format`
+ * the existing JSON format — `.NET String.Format`
  * placeholders. Consumers using a named-args lib (e.g. i18next's `{{name}}`)
  * adapt at the boundary.
  */
@@ -1616,7 +1752,7 @@ interface Localizer {
     t(key: string, args?: readonly unknown[]): string;
 }
 /**
- * Reads the nearest {@link Localizer}. Throws when called outside a provider —
+ * Reads the nearest {@link Localizer}. Throws when called outside a provider
  * mirrors `useDialogService`'s strict behavior. The framework auto-mounts a
  * default `<DefaultLocalizerProvider>` inside `<PowerPortalsProProvider>`, so
  * this only fails when neither is present (typically a misconfigured test).
@@ -1629,11 +1765,9 @@ declare function useLocalizer(): Localizer;
 declare function useT(): Localizer['t'];
 /**
  * Returns a {@link Localizer.t} function with every key automatically
- * prepended with `{prefix}.`. React analog of Blazor's
- * `IPrefixedStringLocalizer` / `IStringLocalizer<T>` — use when a
- * component consumes strings from a known namespace (typically another
- * framework's class-scoped keys) and you don't want to repeat the
- * prefix at every call site.
+ * prepended with `{prefix}.`. Use when a component consumes strings from
+ * a known namespace and you don't want to repeat the prefix at every
+ * call site.
  *
  * Pure sugar over `useT()` — relies on the same auto-mounted
  * `<DefaultLocalizerProvider>` and inherits all of its behavior
@@ -1643,12 +1777,10 @@ declare function useT(): Localizer['t'];
  *
  * @example
  * ```tsx
- * const t = usePrefixedT(
- *   'components.PowerPortalsPro.Web.Blazor.FluentUI.Components.Theme.ThemeColorSelector',
- * );
- * t('OfficeColor.0');
+ * const t = usePrefixedT('components.MyApp.Pages.Editors.TextEditDemoPage');
+ * t('title');
  * // → looks up
- * //   'components.PowerPortalsPro.Web.Blazor.FluentUI.Components.Theme.ThemeColorSelector.OfficeColor.0'
+ * // 'components.MyApp.Pages.Editors.TextEditDemoPage.title'
  * ```
  *
  * The returned function is stable per `prefix` value (memoized via
@@ -1714,12 +1846,12 @@ declare function useLocalizationPrefetcher(): LocalizationPrefetcher | null;
  * the strings are ready.
  *
  * Accepts prefix or full-key shapes:
- *  - `tables.{tablename}` (token) → loads `tables.<tablename>.*` strings
- *  - `tables.account.label` (key) → coerced to `tables.account`
- *  - `views.{viewId}` (token) → loads `views.<viewId>.*` strings
- *  - `tables.account.views.{viewId}.foo` (key) → coerced to `views.<viewId>`
- *  - Anything else (`app.*`, `components.*`) → silently dropped; covered
- *    by the default bundle loaded on app boot.
+ * - `tables.{tablename}` (token) → loads `tables.<tablename>.*` strings
+ * - `tables.account.label` (key) → coerced to `tables.account`
+ * - `views.{viewId}` (token) → loads `views.<viewId>.*` strings
+ * - `tables.account.views.{viewId}.foo` (key) → coerced to `views.<viewId>`
+ * - Anything else (`app.*`, `components.*`) → silently dropped; covered
+ * by the default bundle loaded on app boot.
  *
  * Re-fires only when `prefixes` changes by VALUE — passing a fresh array
  * with the same content each render doesn't requeue. Already-fetched
@@ -1733,8 +1865,8 @@ declare function useLocalizationPrefetcher(): LocalizationPrefetcher | null;
  * @example
  * ```tsx
  * function MyAccountPage() {
- *   useLocalization(['tables.account', 'tables.contact']);
- *   return <Form>...</Form>;
+ * useLocalization(['tables.account', 'tables.contact']);
+ * return <Form>...</Form>;
  * }
  * ```
  */
@@ -1752,9 +1884,9 @@ declare function useLocalization(prefixes: readonly string[]): void;
  * @example
  * ```tsx
  * function MyForm() {
- *   const ready = useLocalizationLoaded(['tables.account']);
- *   if (!ready) return <Spinner />;
- *   return <Form>...</Form>;
+ * const ready = useLocalizationLoaded(['tables.account']);
+ * if (!ready) return <Spinner />;
+ * return <Form>...</Form>;
  * }
  * ```
  */
@@ -1770,9 +1902,8 @@ declare function LocalizerProvider({ value, children, }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 /**
- * Flattens a nested object (Blazor's localization JSON shape) into a flat
- * `key.path → value` map. Drops non-string leaves (no use for them in the
- * localizer's lookup).
+ * Flattens a nested object into a flat `key.path → value` map. Drops
+ * non-string leaves (no use for them in the localizer's lookup).
  */
 declare function flattenStrings(obj: Record<string, unknown>, prefix?: string): Record<string, string>;
 /**
@@ -1817,9 +1948,9 @@ declare function createLocalizer(strings: Record<string, string>, options?: Crea
 declare function resolveLocalizationUrl(template: string, locale: string): string;
 /**
  * Cookie name ASP.NET Core's `CookieRequestCultureProvider` uses to persist
- * the active culture. Same cookie the Blazor stack sets via the
- * <c>/Culture/{culture}</c> endpoint, so reading/writing it here keeps the
- * React and Blazor stacks in sync when both are hosted side-by-side.
+ * the active culture. Reading and writing this cookie keeps the React app
+ * in sync with any same-origin server-rendered surface that reads its
+ * culture from the same source.
  */
 declare const ASP_NET_CULTURE_COOKIE = ".AspNetCore.Culture";
 /**
@@ -1833,10 +1964,9 @@ declare const ASP_NET_CULTURE_COOKIE = ".AspNetCore.Culture";
 declare function getAspNetCultureCookie(): string | null;
 /**
  * Writes the ASP.NET Core culture cookie with both `c` and `uic` segments
- * set to the same value. Mirrors what the server-side
- * <c>/Culture/{culture}</c> endpoint sets, so a React-side locale change
- * immediately affects subsequent server-rendered Blazor pages on the same
- * origin (and vice versa).
+ * set to the same value. A React-side locale change immediately affects
+ * subsequent same-origin server-rendered pages that read their culture
+ * from the same cookie (and vice versa).
  *
  * Defaults to `path=/`, 1-year expiry, `SameSite=Lax`. Safe to call in
  * non-browser environments (no-op).
@@ -1846,7 +1976,7 @@ declare function setAspNetCultureCookie(culture: string, options?: {
     maxAgeSeconds?: number;
 }): void;
 /**
- * Default regex matching a locale code at the start of `window.location.pathname` —
+ * Default regex matching a locale code at the start of `window.location.pathname`
  * shapes like `/en`, `/en/`, `/en-US/page`, `/fr-CA/path/x`. Captures the
  * locale code in group 1. Only 2-letter primary tags + optional 2–4-letter
  * subtag (script / region) are recognized; arbitrary path segments don't
@@ -1861,16 +1991,52 @@ declare const DEFAULT_URL_LOCALE_PATTERN: RegExp;
  * Safe to call in non-browser environments (returns `null`).
  */
 declare function getLocaleFromUrlPath(pattern?: RegExp): string | null;
+/**
+ * The server's configured URL-culture strategy, surfaced to the client through
+ * the localization manifest (`urlCultureStrategy`). Mirrors the C#
+ * `PowerPortalsPro.Web.Options.UrlCultureStrategy` enum names:
+ *
+ * - `PathPrefix` — default locale bare (`/contacts`), others prefixed (`/fr/contacts`).
+ * - `PathPrefixAll` — every locale prefixed, including the default (`/en/contacts`).
+ * - `CookieOnly` — the locale never appears in the URL; switching is in-place.
+ */
+type UrlCultureStrategyName = 'PathPrefix' | 'PathPrefixAll' | 'CookieOnly';
+/**
+ * Whether a URL for `locale` carries a `/{locale}` path prefix under `strategy`.
+ * Runtime mirror of the server-side `CultureUrls.ShouldPrefix` so client-built
+ * links match the shape the LocalizationMiddleware actually serves.
+ */
+declare function shouldPrefixLocale(strategy: UrlCultureStrategyName, locale: string, defaultLocale: string): boolean;
+/**
+ * Removes a leading `/{locale}` segment from `pathname` when that segment is one
+ * of `supportedLocales`. Returns the "cultureless" path (always leading-slash,
+ * `/` for root). Mirror of the server-side `StripCulturePrefix`.
+ */
+declare function stripLocalePrefix(pathname: string, supportedLocales: readonly string[]): string;
+/**
+ * Builds the path (leading slash, no origin) at which `locale` serves the current
+ * page under `strategy`, given the current `pathname` (which may already carry a
+ * locale prefix) and the server's `supportedLocales`. Runtime mirror of the
+ * server-side `CultureUrls.BuildPath`. Use it to compute the navigation target
+ * when switching locale under a prefix strategy.
+ */
+declare function buildLocalePath(options: {
+    strategy: UrlCultureStrategyName;
+    locale: string;
+    defaultLocale: string;
+    pathname: string;
+    supportedLocales: readonly string[];
+}): string;
 /**
  * Resolves the active locale from common sources, in order of precedence:
  *
  * 1. URL path segment (`/en/...`) — picked up via {@link getLocaleFromUrlPath}
- *    when `matchUrl` is `true` (default).
+ * when `matchUrl` is `true` (default).
  * 2. ASP.NET culture cookie (`.AspNetCore.Culture`) — picked up via
- *    {@link getAspNetCultureCookie}.
+ * {@link getAspNetCultureCookie}.
  * 3. `navigator.language` — when `matchBrowser` is `true` (default), strips
- *    the region (e.g. `en-US` → `en`) for compatibility with bundle locale
- *    codes which are typically primary-tag only.
+ * the region (e.g. `en-US` → `en`) for compatibility with bundle locale
+ * codes which are typically primary-tag only.
  * 4. The supplied `fallback` (default `'en'`).
  *
  * Used by `<LocaleProvider>` for auto-detection; also exported for consumer
@@ -1888,6 +2054,21 @@ interface LocaleState {
     /** Replace the active locale. Triggers re-fetch of localization JSONs. */
     readonly setLocale: (locale: string) => void;
 }
+/**
+ * Reads the server's configured {@link UrlCultureStrategyName} from the
+ * {@link LocalizationManifestContext} (populated by
+ * {@link DefaultLocalizerProvider}'s manifest fetch). Returns `undefined`
+ * before the manifest lands, or when no provider is mounted. Consumers
+ * building a custom locale switcher use this to decide whether to navigate
+ * to a `/{locale}` URL or switch in place.
+ */
+declare function useUrlCultureStrategy(): UrlCultureStrategyName | undefined;
+/**
+ * Reads the server's default locale — the first entry of the manifest's
+ * supported-locale list (the server emits it default-culture-first). Returns
+ * `undefined` before the manifest lands, or when no provider is mounted.
+ */
+declare function useDefaultLocale(): string | undefined;
 /**
  * Reads the active locale state, falling back to `{ locale: 'en' }` when no
  * `<LocaleProvider>` is mounted. Apps that don't need locale switching can
@@ -1916,11 +2097,10 @@ interface LocaleProviderProps {
      */
     urlPattern?: RegExp | null;
     /**
-     * Persist locale changes to the ASP.NET culture cookie (the same cookie
-     * Blazor's locale switcher writes via `/Culture/{culture}`). Default
-     * `true` — keeps the React + Blazor stacks in sync when both render
-     * pages on the same origin. Pass `false` to manage persistence yourself
-     * (e.g. via the `onLocaleChange` callback).
+     * Persist locale changes to the ASP.NET culture cookie. Default `true` —
+     * keeps any same-origin server-rendered page in sync with the React-side
+     * locale. Pass `false` to manage persistence yourself (e.g. via the
+     * `onLocaleChange` callback).
      */
     persistToCookie?: boolean;
     /**
@@ -1948,9 +2128,9 @@ interface LocaleProviderProps {
  * Example:
  * ```tsx
  * <LocaleProvider initialLocale="en">
- *   <PowerPortalsProProvider>
- *     <App />  {/* useLocale() inside returns { locale: 'en', setLocale: ... } *\/}
- *   </PowerPortalsProProvider>
+ * <PowerPortalsProProvider>
+ * <App /> {/* useLocale() inside returns { locale: 'en', setLocale: ... } *\/}
+ * </PowerPortalsProProvider>
  * </LocaleProvider>
  * ```
  */
@@ -1969,7 +2149,7 @@ interface DefaultLocalizerProviderProps {
      */
     urls?: readonly string[];
     /**
-     * @deprecated Use {@link urls} instead. Kept for backwards compatibility —
+     * @deprecated Use {@link urls} instead. Kept for backwards compatibility
      * when set, treated as `urls: [url]`.
      */
     url?: string;
@@ -2054,9 +2234,9 @@ declare function DefaultLocalizerProvider({ urls, url, onMissingKey, prefixes, c
  * dismissed the dialog (clicked the secondary button on a confirmation,
  * pressed Escape, clicked the backdrop, or otherwise rejected the action).
  *
- * Mirrors Blazor's `DialogResult` shape — kept as an object rather than a
- * naked boolean so we can extend with `data?` etc. when custom-content
- * dialogs land without a wire-breaking change.
+ * Kept as an object rather than a naked boolean so we can extend with
+ * `data?` etc. when custom-content dialogs land without a wire-breaking
+ * change.
  */
 interface DialogResult {
     /** True when the user dismissed/cancelled, false when they confirmed. */
@@ -2077,19 +2257,17 @@ interface ConfirmationDialogOptions extends DialogOptions {
     secondaryText?: string;
 }
 /**
- * Headless dialog service contract — equivalent to Blazor's `IDialogService`.
- * The framework calls these methods to surface success/warning/error/info
- * messages and confirmation prompts; consumers provide the concrete
- * implementation via {@link DialogServiceProvider} (typically the Fluent UI
- * implementation that ships with `@powerportalspro/react-fluent`, but any
- * dialog UI works as long as it satisfies this contract).
+ * Headless dialog service contract. The framework calls these methods to
+ * surface success / warning / error / info messages and confirmation
+ * prompts; consumers provide the concrete implementation via
+ * {@link DialogServiceProvider} (typically the Fluent UI implementation
+ * that ships with `@powerportalspro/react-fluent`, but any dialog UI
+ * works as long as it satisfies this contract).
  *
- * **Message format.** The `message` argument is treated as HTML markup —
- * matching Blazor's `Microsoft.FluentUI.AspNetCore.Components.IDialogService`,
- * which renders messages via `MarkupString`. Tags like `<br/>`, `<strong>`,
- * `<em>` work; framework localization strings (e.g.
- * `app.messages.unsaved-changes`) rely on this. Don't pass unsanitized user
- * input — same constraint as Blazor.
+ * **Message format.** The `message` argument is treated as trusted HTML
+ * markup — the framework's bundled localization strings (e.g.
+ * `app.messages.unsaved-changes`) rely on this for inline `<br/>`,
+ * `<strong>`, `<em>` tags. Don't pass unsanitized user input.
  *
  * Each method returns a {@link DialogResult} so the same shape covers both
  * single-button (always `{ cancelled: false }` once dismissed) and
@@ -2119,18 +2297,18 @@ declare function DialogServiceProvider({ value, children, }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;
 /**
- * Prompts the user about unsaved changes. Returns `true` if the user wants to
- * continue (discarding their edits), `false` if they want to cancel and keep
- * editing. Mirrors Blazor's `IPowerPortalsProDialogService.WarnAboutUnsavedChangesAsync`.
+ * Prompts the user about unsaved changes. Returns `true` if the user wants
+ * to continue (discarding their edits), `false` if they want to cancel and
+ * keep editing.
  *
- * Used by the framework before navigation, refresh, and any other operation
- * that would discard pending edits. Application code can also call it directly
- * for custom flows.
+ * Used by the framework before navigation, refresh, and any other
+ * operation that would discard pending edits. Application code can also
+ * call it directly for custom flows.
  *
  * Strings come from the supplied {@link Localizer} (default English from
- * the framework's bundled JSON). Keys: `app.messages.unsaved-changes` (body),
- * `app.messages.unsaved-changes-title` (title), `app.buttons.yes.label` /
- * `app.buttons.no.label` (button labels).
+ * the framework's bundled JSON). Keys: `app.messages.unsaved-changes`
+ * (body), `app.messages.unsaved-changes-title` (title),
+ * `app.buttons.yes.label` / `app.buttons.no.label` (button labels).
  */
 declare function warnAboutUnsavedChangesAsync(dialog: DialogService, localizer: Localizer): Promise<boolean>;
 /**
@@ -2162,11 +2340,10 @@ interface OverlayInstance extends OverlayOptions {
     readonly id: string;
 }
 /**
- * Headless overlay service contract — equivalent to Blazor's
- * `IOverlayService`. Maintains a per-target stack of overlay instances; the
- * topmost instance for a target is what renders. Concrete implementations
- * (e.g. `<FluentOverlayProvider>` from `@powerportalspro/react-fluent`)
- * provide the actual UI.
+ * Headless overlay service contract. Maintains a per-target stack of
+ * overlay instances; the topmost instance for a target is what renders.
+ * Concrete implementations (e.g. `<FluentOverlayProvider>` from
+ * `@powerportalspro/react-fluent`) provide the actual UI.
  *
  * Reads happen via the {@link useOverlayForTarget} hook — that's how
  * components subscribe to "what overlay should I currently render". The
@@ -2217,9 +2394,7 @@ declare function useOverlayServiceState(): OverlayContextValue;
 /**
  * Run an async operation while showing an overlay. Hides on success or
  * failure (the overlay is dismissed in `finally`, so failures don't leave a
- * stuck spinner). Mirrors the try/finally pattern Blazor's
- * `MainContext.SaveAsync` uses around `_overlayService.ShowOverlayAsync` /
- * `HideOverlayAsync`.
+ * stuck spinner).
  */
 declare function runWithOverlayAsync<T>(service: OverlayService | null, options: OverlayOptions, operation: () => Promise<T>): Promise<T>;
 /**
@@ -2259,12 +2434,12 @@ declare function useUnsavedChangesWarning(): void;
  * guard needs:
  *
  * - `isAnyDirty` — reactive boolean tracking whether any registered
- *   top-most {@link MainContext} / {@link RecordContext} on the page is
- *   dirty (read-through to {@link useIsAnyDirty}).
+ * top-most {@link MainContext} / {@link RecordContext} on the page is
+ * dirty (read-through to {@link useIsAnyDirty}).
  * - `warn` — async function that opens the framework confirmation dialog
- *   and resolves `true` if the user confirmed discarding the edits,
- *   `false` if they cancelled (read-through to
- *   {@link useWarnAboutUnsavedChanges}).
+ * and resolves `true` if the user confirmed discarding the edits,
+ * `false` if they cancelled (read-through to
+ * {@link useWarnAboutUnsavedChanges}).
  *
  * Router-agnostic — this package has zero router dependencies. Pair it
  * with whichever router blocker your app uses:
@@ -2276,24 +2451,24 @@ declare function useUnsavedChangesWarning(): void;
  * ```tsx
  * import { useBlocker } from 'react-router-dom';
  * function MyGuard() {
- *   const guard = useUnsavedChangesGuard();
- *   const blocker = useBlocker(
- *     ({ currentLocation, nextLocation }) =>
- *       guard.isAnyDirty &&
- *       currentLocation.pathname !== nextLocation.pathname,
- *   );
- *   useEffect(() => {
- *     if (blocker.state !== 'blocked') return;
- *     let cancelled = false;
- *     (async () => {
- *       const proceed = await guard.warn();
- *       if (cancelled) return;
- *       if (proceed) blocker.proceed();
- *       else blocker.reset();
- *     })();
- *     return () => { cancelled = true; };
- *   }, [blocker, guard]);
- *   return null;
+ * const guard = useUnsavedChangesGuard();
+ * const blocker = useBlocker(
+ * ({ currentLocation, nextLocation }) =>
+ * guard.isAnyDirty &&
+ * currentLocation.pathname !== nextLocation.pathname,
+ * );
+ * useEffect(() => {
+ * if (blocker.state !== 'blocked') return;
+ * let cancelled = false;
+ * (async () => {
+ * const proceed = await guard.warn();
+ * if (cancelled) return;
+ * if (proceed) blocker.proceed();
+ * else blocker.reset();
+ * })();
+ * return () => { cancelled = true; };
+ * }, [blocker, guard]);
+ * return null;
  * }
  * ```
  *
@@ -2304,14 +2479,14 @@ declare function useUnsavedChangesWarning(): void;
  * ```tsx
  * import { useBlocker } from '@tanstack/react-router';
  * function MyGuard() {
- *   const guard = useUnsavedChangesGuard();
- *   useBlocker({
- *     blockerFn: async () => {
- *       if (!guard.isAnyDirty) return true;       // allow
- *       return await guard.warn();                // user choice
- *     },
- *   });
- *   return null;
+ * const guard = useUnsavedChangesGuard();
+ * useBlocker({
+ * blockerFn: async () => {
+ * if (!guard.isAnyDirty) return true; // allow
+ * return await guard.warn(); // user choice
+ * },
+ * });
+ * return null;
  * }
  * ```
  *
@@ -2375,11 +2550,11 @@ interface UnsavedChangesReporter {
  * {@link PowerPortalsProProvider}; consumed by:
  *
  * - The auto-registration effect inside topmost
- *   {@link MainContext} / {@link RecordContext}, which adds a reporter on
- *   mount + removes it on unmount.
+ * {@link MainContext} / {@link RecordContext}, which adds a reporter on
+ * mount + removes it on unmount.
  * - `<RouterUnsavedChangesGuard>` (in `@powerportalspro/react-fluent`),
- *   which subscribes via {@link useIsAnyDirty} and gates `useBlocker` on
- *   the aggregate.
+ * which subscribes via {@link useIsAnyDirty} and gates `useBlocker` on
+ * the aggregate.
  *
  * Router-agnostic by design — the registry knows nothing about
  * react-router, history, or navigation events. That coupling lives in
@@ -2521,4 +2696,4 @@ declare function ValidationProvider({ children }: {
 
 declare const VERSION = "0.1.0";
 
-export { ASP_NET_CULTURE_COOKIE, type AuthState, AuthStatus, AuthorizedView, type AuthorizedViewProps, type ColumnValidator, type ConfirmationDialogOptions, type CreateLocalizerOptions, DEFAULT_URL_LOCALE_PATTERN, DefaultLocalizerProvider, type DefaultLocalizerProviderProps, type DialogOptions, type DialogResult, type DialogService, DialogServiceProvider, type EnvironmentFileSettingsCache, InMemoryEnvironmentFileSettingsCache, InMemoryTableMetadataCache, InMemoryViewMetadataCache, InMemoryViewsForTableCache, LocaleProvider, type LocaleProviderProps, type LocaleState, type LocalizationPrefetcher, type Localizer, LocalizerProvider, LookupRecordContext, type LookupRecordContextProps, MainContext, type MainContextDescendant, type MainContextProps, MainContextProvider, type MainContextValue, type OverlayInstance, type OverlayOptions, type OverlayService, OverlayServiceProvider, PowerPortalsProContext, type PowerPortalsProContextValue, PowerPortalsProProvider, type PowerPortalsProProviderProps, type QueryResult, QueryStatus, RecordContext, type RecordContextProps, type RecordContextValue, type TableMetadataCache, type UnsavedChangesGuardController, type UnsavedChangesRegistry, UnsavedChangesRegistryProvider, type UnsavedChangesRegistryProviderProps, type UnsavedChangesReporter, type UseAuthResult, type UseEnvironmentFileSettingsOptions, type UseFetchRecordsOptions, type UseGridDataOptions, type UseRecordOptions, type UseSupportedLocalesOptions, type UseTableMetadataOptions, type UseTablePermissionsOptions, type UseViewDataSourceOptions, type UseViewMetadataOptions, type UseViewsForTableOptions, VERSION, type ValidationContextValue, ValidationProvider, type ViewDataSource, type ViewDataSourceHighlight, type ViewMetadataCache, type ViewsForTableCache, createLocalizer, detectLocale, flattenStrings, getAspNetCultureCookie, getLocaleFromUrlPath, interpolate, resolveLocalizationUrl, runWithOverlayAsync, setAspNetCultureCookie, useAuth, useColumnMetadata, useColumnValidationErrors, useDialogService, useEnvironmentFileSettings, useFetchRecords, useGridData, useIsAnyDirty, useLocale, useLocalization, useLocalizationLoaded, useLocalizationPrefetcher, useLocalizer, useMainContext, useOverlayForTarget, useOverlayService, useOverlayServiceState, usePowerPortalsPro, usePrefixedT, useQueryParam, useRecord, useRecordContext, useRecordContextOptional, useRunWithOverlay, useSupportedLocales, useT, useTableMetadata, useTablePermissions, useUnsavedChangesGuard, useUnsavedChangesRegistry, useUnsavedChangesWarning, useValidationContext, useViewDataSource, useViewMetadata, useViewsForTable, useWarnAboutUnsavedChanges, warnAboutUnsavedChangesAsync };
+export { ASP_NET_CULTURE_COOKIE, type AuthState, AuthStatus, AuthorizedView, type AuthorizedViewProps, type ColumnValidator, type ConfirmationDialogOptions, type CreateLocalizerOptions, DEFAULT_URL_LOCALE_PATTERN, DefaultLocalizerProvider, type DefaultLocalizerProviderProps, type DialogOptions, type DialogResult, type DialogService, DialogServiceProvider, InMemoryOrganizationSettingsCache, InMemoryTableMetadataCache, InMemoryViewMetadataCache, InMemoryViewsForTableCache, LocaleProvider, type LocaleProviderProps, type LocaleState, type LocalizationPrefetcher, type Localizer, LocalizerProvider, LookupRecordContext, type LookupRecordContextProps, MainContext, type MainContextDescendant, type MainContextProps, MainContextProvider, type MainContextValue, MaskMode, type MaskOptions, type NumericOptions, type OrganizationSettingsCache, type OverlayInstance, type OverlayOptions, type OverlayService, OverlayServiceProvider, PowerPortalsProContext, type PowerPortalsProContextValue, PowerPortalsProProvider, type PowerPortalsProProviderProps, type QueryResult, QueryStatus, RecordContext, type RecordContextProps, type RecordContextValue, type ReformatResult, type TableMetadataCache, type UnsavedChangesGuardController, type UnsavedChangesRegistry, UnsavedChangesRegistryProvider, type UnsavedChangesRegistryProviderProps, type UnsavedChangesReporter, type UrlCultureStrategyName, type UseAuthResult, type UseFetchRecordsOptions, type UseGridDataOptions, type UseMaskedTextFieldOptions, type UseMaskedTextFieldReturn, type UseOrganizationSettingsOptions, type UseRecordOptions, type UseSupportedLocalesOptions, type UseTableMetadataOptions, type UseTablePermissionsOptions, type UseViewDataSourceOptions, type UseViewMetadataOptions, type UseViewsForTableOptions, VERSION, type ValidationContextValue, ValidationProvider, type ViewDataSource, type ViewDataSourceHighlight, type ViewMetadataCache, type ViewsForTableCache, buildLocalePath, createLocalizer, detectLocale, flattenStrings, getAspNetCultureCookie, getLocaleFromUrlPath, interpolate, reformat, resolveLocalizationUrl, runWithOverlayAsync, setAspNetCultureCookie, shouldPrefixLocale, stripLocalePrefix, useAuth, useColumnMetadata, useColumnValidationErrors, useDefaultLocale, useDialogService, useFetchRecords, useGridData, useIsAnyDirty, useLocale, useLocalization, useLocalizationLoaded, useLocalizationPrefetcher, useLocalizer, useMainContext, useMaskedTextField, useOrganizationSettings, useOverlayForTarget, useOverlayService, useOverlayServiceState, usePowerPortalsPro, usePrefixedT, useQueryParam, useRecord, useRecordContext, useRecordContextOptional, useRunWithOverlay, useSupportedLocales, useT, useTableMetadata, useTablePermissions, useUnsavedChangesGuard, useUnsavedChangesRegistry, useUnsavedChangesWarning, useUrlCultureStrategy, useValidationContext, useViewDataSource, useViewMetadata, useViewsForTable, useWarnAboutUnsavedChanges, warnAboutUnsavedChangesAsync };