nexus-shared 2.0.0 → 3.1.0

package/dist/Interfaces/ExcelInterfaces.d.ts

@@ -0,0 +1,227 @@
+import type { ApiEndpoint, ApiModuleValue, AppModule } from "./ApiInterfaces.ts";
+/**
+ * What one column of a sheet holds. It decides the cell's format in the file, the check the spreadsheet makes while
+ * the person types, and the input the review editors draw. The numbers are the backend's (`EExcelDataTypes`); an
+ * object, not an enum, so a test that strips types can import it.
+ */
+export declare const ExcelDataType: {
+    /** One line of text: a name, a code. */
+    readonly Text: 0;
+    /** Many lines of text: a description, a note. */
+    readonly Note: 1;
+    /** A whole number, no decimals. */
+    readonly WholeNumber: 2;
+    /** A number with decimals. */
+    readonly Decimal: 3;
+    /** Money: decimals fixed at the backend's places. */
+    readonly Amount: 4;
+    /** A date with no time, as an ISO date: `2026-09-29`. */
+    readonly Date: 5;
+    /** A date and a time, zone-less, as `2026-09-29 14:30`. */
+    readonly DateTime: 6;
+    /** A time of day with no date: `14:30`. */
+    readonly Time: 7;
+    /** Yes or No. */
+    readonly YesNo: 8;
+    /** A choice from a list the backend owns, picked in the sheet and travelling as its key. */
+    readonly List: 9;
+};
+export type ExcelDataType = (typeof ExcelDataType)[keyof typeof ExcelDataType];
+/** What one row of an upload turned out to be. The backend's `EExcelRowKinds`. */
+export declare const ExcelRowKind: {
+    /** Nothing is wrong with it and it is not a record yet: this is what an import writes. */
+    readonly New: 0;
+    /** It is already a record, or repeats a row earlier in the file. Nothing updates it. */
+    readonly Duplicate: 1;
+    /** Something in it has to be fixed before it can be written. */
+    readonly Invalid: 2;
+};
+export type ExcelRowKind = (typeof ExcelRowKind)[keyof typeof ExcelRowKind];
+/** One column of a sheet: enough to draw a heading, know what the cell holds, and check it before anything is sent. */
+export interface ExcelColumnInfo {
+    /** The property behind it, and the key every row's values are held under: `CityName`. */
+    field: string;
+    /** The heading the person reads: "City name". */
+    header: string;
+    dataType: ExcelDataType;
+    /** A row with this cell empty is refused. */
+    isRequired?: boolean;
+    /** The file fills it, not the person. */
+    isReadOnly?: boolean;
+    /** It is a choice: it travels as a key with its words beside it, and is picked in the sheet. */
+    isReference?: boolean;
+    /** The list it picks from. */
+    list?: string | null;
+    minLength?: number;
+    maxLength?: number;
+    /** Least value of a number. Only a number has one. */
+    minimum?: number | null;
+    /** Most value of a number. */
+    maximum?: number | null;
+    /** What the person reads about this column, in their words. */
+    note?: string | null;
+}
+/**
+ * The limits and the shape of a sheet, asked for before either side is offered: so an export that will be cut short is
+ * said before it is written, and the editors know what they are drawing. It is the same for everybody and changes once
+ * a release, so it is kept.
+ */
+export interface ExcelSettings {
+    /** What one row is: "City". */
+    subject: string;
+    /** What the downloaded template is called. */
+    templateFileName?: string;
+    /** Rows the template offers to fill. */
+    sheetRows?: number;
+    /** The most rows one export writes. Over this, the person is warned first. */
+    maxExportRows: number;
+    /** The most rows one import takes. */
+    maxImportRows: number;
+    /** The columns, in the order they read. */
+    columns: ExcelColumnInfo[];
+    /**
+     * How each column should be drawn as an input. **Empty** until the backend can describe an input, and `columns` is
+     * what the editors draw from until it is not.
+     */
+    inputs?: readonly unknown[];
+    /**
+     * The statuses a new record may start in when it is imported, each with its words: the import offers them as a
+     * choice. Empty, or absent, when the model offers none, and then no choice is shown.
+     */
+    recordStatuses?: ExcelRecordStatus[];
+    /** The status picked unless the person picks another: the backend's "Imported". */
+    defaultRecordStatus?: number;
+}
+/** One status an imported record may start in: the backend's number, and the words for it. */
+export interface ExcelRecordStatus {
+    value: number;
+    label: string;
+}
+/** One thing wrong with one cell, told so the person can find it. */
+export interface ExcelCellProblem {
+    /** The row of the sheet, the number down the side of the file. */
+    row: number;
+    /** The column, counting from 1. */
+    column: number;
+    /** The cell as a spreadsheet names it: `B7`. */
+    cell: string;
+    /** The column's heading, in the person's words. */
+    header: string;
+    /** The property behind it, which is what an editor binds to. */
+    field: string;
+    /** What to tell the person, in plain words. */
+    message: string;
+    /** The unique code of the line that found it, for a developer. */
+    messageCode?: string;
+    /** What kind of failure it is, as a number. */
+    errorCode?: number;
+}
+/** One row of the review: what it holds, what it turned out to be, and what is wrong with it. */
+export interface ExcelReviewRow {
+    /** The row of the sheet, so the person can find it in their own file. */
+    number: number;
+    kind: ExcelRowKind;
+    /** What each column held, by the property's name. A choice holds its key, never a plain id. */
+    values: Record<string, string | null>;
+    /** What the person picked in each choice, for the review to show. */
+    labels?: Record<string, string | null>;
+    /** Everything wrong with the row, one per cell. */
+    problems?: ExcelCellProblem[];
+    /** Why it is a duplicate, in the person's words. */
+    duplicate?: string | null;
+}
+/** What a verify answers: the whole upload, counted and told row by row. Nothing was written. */
+export interface ExcelVerifyAnswer {
+    /** What one row is. */
+    subject: string;
+    /** Rows that had something in them. Empty rows of the template are not counted. */
+    read: number;
+    /** Rows an import would write. */
+    new: number;
+    /** Rows that are already records, or repeat one earlier in the file. */
+    duplicates: number;
+    /** Rows with something to fix. */
+    invalid: number;
+    /** An import would write something and nothing is waiting on a fix. */
+    isReady: boolean;
+    /** The upload in one sentence, for above the review. */
+    note: string;
+    /** The columns, in the order they read. */
+    columns: ExcelColumnInfo[];
+    /** Every row that had something in it. */
+    rows: ExcelReviewRow[];
+    /** Empty until the backend can describe an input. */
+    inputs?: readonly unknown[];
+}
+/**
+ * One row as it travels, in text and nothing else. The same shape in both directions, which is the point: a verify
+ * reads it out of the file and answers with it, the person fixes what they need to, and the import sends the same rows
+ * back to be read again by the same code. A reference column holds its key.
+ */
+export interface ExcelSheetRow {
+    /** The row of the sheet this came from, so every problem can name where it is. */
+    number: number;
+    /** What each column held, by the property's name. A reference holds its key. */
+    values: Record<string, string | null>;
+    /** What the person picked in each reference column: "Nepal (NP)". */
+    labels?: Record<string, string | null>;
+}
+/** What an import did: what it wrote, and what it did not, in the person's words. */
+export interface ExcelImportAnswer {
+    /** Rows the request carried. */
+    sent: number;
+    /** Records written. */
+    created: number;
+    /** Rows that were already records. Nothing was updated. */
+    duplicates: number;
+    /** Rows that still had something to fix. */
+    invalid: number;
+    /** The rows nothing was written for, so the person sees which and why without asking again. */
+    refused?: ExcelReviewRow[];
+    /** What happened, in one sentence. */
+    note: string;
+}
+/**
+ * The endpoints of one model's spreadsheets. `excelEndpoints` builds the Nexus ones; an app on another backend writes
+ * its own object of the same four or five.
+ *
+ * `export` is the model's own action, because only the model knows what the person has on screen - the search, the
+ * filters, which list they are looking at, and whose rows they may see. Without one, no export is offered.
+ */
+export interface ExcelEndpoints<TModule extends ApiModuleValue = AppModule> {
+    /** The limits and the shape of the sheet. The one answer a browser may keep. */
+    settings: ApiEndpoint<TModule>;
+    /** The template to fill, as a file. */
+    template: ApiEndpoint<TModule>;
+    /** A filled file read and judged, with nothing written. */
+    verify: ApiEndpoint<TModule>;
+    /** Writes the rows a verify answered with, as the person left them. */
+    import: ApiEndpoint<TModule>;
+    /** The model's own export, with the search on screen. */
+    export?: ApiEndpoint<TModule>;
+}
+/** What the person has on screen, as an export asks for it. The model's own filters go in `filters`. */
+export interface ExcelExportQuery {
+    /** The search box's text. */
+    search?: string | null;
+    /** The sorted column, as the server names it. */
+    sort?: string | null;
+    /** Which way it is sorted. */
+    direction?: "asc" | "desc";
+    /** The filters the page holds, sent as they are: a list, a date range, a status. */
+    filters?: Record<string, unknown>;
+}
+/** A file an endpoint answered with, and what it says about itself. */
+export interface ExcelDownload {
+    blob: Blob;
+    /** The name the answer gave it (`Content-Disposition`), else the one that was asked for. */
+    fileName: string;
+    /** Rows written into the file, when the answer says. */
+    rows?: number;
+    /** Rows asked for that did not fit under the limit. */
+    skipped?: number;
+    /** The most rows one export writes, as the backend has it. */
+    limit?: number;
+    /** What to tell the person when rows were left out. */
+    note?: string;
+}

package/dist/Interfaces/ExcelInterfaces.js

@@ -0,0 +1,45 @@
+/*
+ * Types of the spreadsheet side: what a model's sheet is made of, what a verify answers, what an import sends back, and
+ * the endpoints that serve all three. One shape travels both ways (`ExcelSheetRow`), so a verify and an import can
+ * never disagree about a row.
+ *
+ * A reference column travels as its **key** - an encrypted id made for the person who downloaded the file - with the
+ * words they picked beside it. The plain id in the sheet is theirs to read and is never read back, so a value copied
+ * out of a spreadsheet, or out of a verify answer, cannot be posted to an endpoint as an id.
+ */
+/**
+ * What one column of a sheet holds. It decides the cell's format in the file, the check the spreadsheet makes while
+ * the person types, and the input the review editors draw. The numbers are the backend's (`EExcelDataTypes`); an
+ * object, not an enum, so a test that strips types can import it.
+ */
+export const ExcelDataType = {
+    /** One line of text: a name, a code. */
+    Text: 0,
+    /** Many lines of text: a description, a note. */
+    Note: 1,
+    /** A whole number, no decimals. */
+    WholeNumber: 2,
+    /** A number with decimals. */
+    Decimal: 3,
+    /** Money: decimals fixed at the backend's places. */
+    Amount: 4,
+    /** A date with no time, as an ISO date: `2026-09-29`. */
+    Date: 5,
+    /** A date and a time, zone-less, as `2026-09-29 14:30`. */
+    DateTime: 6,
+    /** A time of day with no date: `14:30`. */
+    Time: 7,
+    /** Yes or No. */
+    YesNo: 8,
+    /** A choice from a list the backend owns, picked in the sheet and travelling as its key. */
+    List: 9,
+};
+/** What one row of an upload turned out to be. The backend's `EExcelRowKinds`. */
+export const ExcelRowKind = {
+    /** Nothing is wrong with it and it is not a record yet: this is what an import writes. */
+    New: 0,
+    /** It is already a record, or repeats a row earlier in the file. Nothing updates it. */
+    Duplicate: 1,
+    /** Something in it has to be fixed before it can be written. */
+    Invalid: 2,
+};

package/dist/Interfaces/FormInterfaces.d.ts

@@ -21,6 +21,8 @@ import type { InputDesign, OptionValue } from "./InputInterfaces.ts";
 import type { Size } from "./TypeInterfaces.ts";
 /** Where a form places an input. The input itself ignores these keys. */
 export interface InputLayoutParams {
+    /** Optional heading before this field when the section changes (Form only). */
+    section?: string;
     /** Columns the input spans in a form's 12-column grid, and in a group form's section. Default 12, the full width. */
     span?: number;
     /** The column's width in a tabular form: a CSS length ("9rem") or pixels. Default by type, e.g. 10rem for text. */
@@ -29,6 +31,17 @@ export interface InputLayoutParams {
     grow?: number;
     /** Leaves the input out, e.g. a field only some roles may see. Its value stays in the data as it was. */
     hidden?: boolean;
+    /**
+     * Other inputs of the same form this one follows (Form only). When any of their values changes, this input draws
+     * again — without mounting again, so nothing typed in it is lost — and its params are read afresh: a getter for
+     * `hidden`, `readOnly`, `readOnlyMessage`, `label`, `hint` or `options` answers for the values as they are now. Its
+     * own rule is checked again too, so a `required` that a getter just switched on or off counts at once. Name the
+     * input itself to follow its own typing (a hint that says what the typed text will become).
+     *
+     * An input that names any is asked `hidden` every time it draws, so it can come and go; one that names none is
+     * asked once, when the form draws.
+     */
+    dependsOn?: readonly string[];
 }
 /** What every input's params have. */
 export interface InputParamsBase<TType extends string = string> extends InputLayoutParams {
@@ -140,6 +153,42 @@ export interface RowsInputProps<TRow extends RowValue = RowValue> {
     removable?: boolean;
     /** Rows can be moved up and down. Default false. */
     sortable?: boolean;
+    /**
+     * Values a row's **position** decides rather than the user: a bitwise enum's value, a line number, a running total.
+     * It is asked after every change — a value typed, a row added, removed, duplicated or **moved** — with every row,
+     * and returns one patch per row (or nothing at all, or nothing for a row).
+     *
+     * The patches are written as if code had set them, so only the cells whose value really changed are drawn again:
+     * moving a row renumbers the column in front of the user and leaves focus where they put it. It runs after every
+     * change, so keep it quick, and pair it with `cellReadOnly` when the user must not type what it writes.
+     */
+    deriveRows?: (rows: TRow[]) => (Partial<TRow> | null | undefined)[] | null | undefined;
+    /**
+     * Which cells hold a **generated** value rather than a typed one: an enum's bitwise value, a line's total. It is
+     * asked for every cell as it renders, so a column can lock and unlock while the form around it changes — params are
+     * fixed once a form opens, and this is the one thing about a cell that is not.
+     *
+     * Return the reason to lock the cell and say why (the input wears its read-only lock and shows the note), `true` to
+     * lock it without a reason, or nothing to leave the cell as its params have it. Locking a cell never stops code from
+     * writing it: that is the point.
+     */
+    cellReadOnly?: (row: TRow, name: string, index: number) => string | boolean | null | undefined;
+    /**
+     * Rows the user did not write and may not change, such as the fields a class inherits from its parent: every cell of
+     * such a row is read-only with the reason returned, and in a tabular form its menu offers nothing and no row can be
+     * moved above it. Return the reason, `true` for no reason, or nothing. Keep such rows first: nothing reorders them.
+     */
+    rowReadOnly?: (row: TRow, index: number) => string | boolean | null | undefined;
+    /**
+     * Params of one cell that differ from its column's: a picker whose choices depend on the row, such as a type argument
+     * that takes a key type in one row and a model in the next. Asked as the row draws, which is when one of its values
+     * changes; return the keys to change (`{ options, selectedOptions }`), or nothing for the column's own params.
+     *
+     * Return the **same object** for the same answer (keep them in a map by what decides them): a new object draws the
+     * cell again, and a picker indexes its options once per array. Rules still come from the column's params — a row's
+     * value is checked the same way in every row — so change what is offered here, not what is required.
+     */
+    cellParams?: (row: TRow, name: string, index: number) => Partial<InputParams> | null | undefined;
     /** Every input is read-only, and rows cannot be added, removed, or moved. */
     readOnly?: boolean;
     /** What the rows say when someone tries to change them. Default "Read-only: these rows cannot be changed." */
@@ -164,8 +213,13 @@ export interface RowsInputHandle<TRow extends RowValue = RowValue> {
     setValue: (rows: readonly TRow[]) => void;
     /** Adds a row with these values (over `newRow`), at `index` or at the end, and focuses its first input. */
     add: (values?: Partial<TRow>, index?: number) => void;
-    /** Removes the row at `index`. */
-    remove: (index: number) => void;
+    /**
+     * Removes the row at `index`, with an Undo under the rows - or none with `undo: false`, for a row the code drops
+     * rather than the person, such as one nothing was typed in.
+     */
+    remove: (index: number, options?: {
+        undo?: boolean;
+    }) => void;
     /** Checks every row, shows every message, and focuses the first problem. Returns whether all is valid. */
     validate: () => boolean;
     /** Brings the row at `index` into view and focuses its input named `name`, or its first input. */
@@ -179,6 +233,17 @@ export interface TabularFormProps<TRow extends RowValue = RowValue> extends Rows
     maxHeight?: number | string;
     /** The row number column. Default true; it is also the button of each row's menu. */
     numbered?: boolean;
+    /**
+     * Where each row's actions sit. `"number"` (the default): a menu beside the row's number. `"end"`: a column fixed at
+     * the right edge, as a data table has them - Remove and Lock as buttons of their own, any other action in a menu
+     * after them.
+     */
+    actionsAt?: "number" | "end";
+    /**
+     * The person can lock a row, and unlock it: a locked row's inputs are read-only and it cannot be removed. The locks
+     * are the screen's, never part of the value - a locked row is still sent. Its button is with the row's actions.
+     */
+    lockable?: boolean;
 }
 /** `GroupForm`: each row as a section of inputs, laid out on a 12-column grid by each input's `span`. */
 export interface GroupFormProps<TRow extends RowValue = RowValue> extends RowsInputProps<TRow> {
@@ -243,7 +308,10 @@ export interface FormProps<TValues extends FormValues = FormValues> {
     readOnly?: boolean;
     /** Every input is disabled, and nothing is checked. */
     disabled?: boolean;
-    /** Shows placeholders in place of the inputs, e.g. while the values load. */
+    /**
+     * The values are loading: the inputs show at once, disabled, so the form has its final size from the first frame, and
+     * nothing typed is taken (even with `disabled` taken off by hand) until it ends. A submit waits too.
+     */
     loading?: boolean;
     id?: string;
     className?: string;
@@ -276,6 +344,13 @@ export type FormSubmitResult<TValues extends FormValues = FormValues> = void | u
 };
 /** Where `SubmitForm` puts its buttons: at the end with the status line before them, at the start, or nowhere (`FormButtons` elsewhere). */
 export type FormButtonsPlacement = "end" | "start" | false;
+/**
+ * What a form's status line reports. `full`: loading, saving, what needs attention, unsaved changes, and when it saved.
+ * `errors`: only an error that belongs to no field, such as the server's "The sign-in took too long", for a short form
+ * that keeps nothing (a sign-in, a search, a code to verify): "Unsaved changes" would be untrue there, the button's
+ * spinner already says it is working, and every field is in view with its own message under it.
+ */
+export type FormStatusLineMode = "full" | "errors";
 /** Props of `SubmitForm`: a `Form` in a `<form>`, checked on submit, with Save, Cancel, and Reset. */
 export interface SubmitFormProps<TValues extends FormValues = FormValues> extends FormProps<TValues> {
     /**
@@ -304,6 +379,8 @@ export interface SubmitFormProps<TValues extends FormValues = FormValues> extend
     resetOnSuccess?: boolean;
     /** Where the buttons go. Default `end`. With `false`, put a `FormButtons` with the same `form` elsewhere, such as a popup's footer. */
     buttons?: FormButtonsPlacement;
+    /** What the status line reports. Default `full`; `errors` for a short form that keeps nothing, such as a sign-in or a search. */
+    statusLine?: FormStatusLineMode;
     /** Asks before the page closes or reloads with unsaved changes. Default: true without a `draftKey` (a draft keeps them). */
     confirmLeave?: boolean;
     /** Name for screen readers. */
@@ -333,8 +410,9 @@ export interface ApiFormProps<TValues extends FormValues = FormValues> extends O
     /** Shapes what is sent, e.g. `{ items: [values] }` for a batch endpoint. May be async. Default: the values. */
     transform?: (values: TValues, context: FormSubmitContext<TValues>) => unknown;
     /**
-     * Reads the server's answer. Default `readApiResponse`: Nexus API responses (`{ isSuccess, message, inputName, result }`),
-     * ASP.NET Core problem details (`{ title, errors }`), and any JSON by its HTTP status.
+     * Reads the server's answer. Default: the app's reader (`configureApi({ read })`), else `readApiResponse`: Nexus API
+     * responses (`{ isSuccess, message, inputName, result }`), ASP.NET Core problem details (`{ title, errors }`), and
+     * any JSON by its HTTP status.
      */
     readResponse?: (body: unknown, status: number | undefined) => ApiResult;
     /** After a save, once the saved values are the form's own, with what the server sent back: close a popup, update a table row. */
@@ -344,8 +422,8 @@ export interface ApiFormProps<TValues extends FormValues = FormValues> extends O
     /** The toast after a save: text, or `false` for none. Default: the server's message, else the endpoint's ("Room saved."), else "Saved." */
     successMessage?: ReactNode | false;
     /**
-     * Loads the values to edit, e.g. a record by id. Placeholders show while it runs, and a failure offers Retry. It runs
-     * once; give the form a new `key` to load another record.
+     * Loads the values to edit, e.g. a record by id. The inputs show disabled while it runs, and a failure offers Retry.
+     * It runs once; give the form a new `key` to load another record.
      */
     loadValue?: (signal: AbortSignal) => Promise<Partial<TValues> | null | undefined>;
 }

package/dist/Interfaces/MessageInterfaces.d.ts

@@ -1,5 +1,5 @@
 /** The actions the builder knows by name (`MESSAGE_ACTION_NAMES`); `actionWords(name)` gives their words. */
-export type MessageActionName = "load" | "save" | "create" | "update" | "delete" | "trash" | "archive" | "restore" | "recover" | "flag" | "unflag" | "pin" | "unpin" | "send" | "submit" | "upload" | "download" | "import" | "export" | "copy" | "approve" | "reject" | "cancel";
+export type MessageActionName = "load" | "save" | "create" | "update" | "delete" | "trash" | "restore" | "recover" | "flag" | "unflag" | "pin" | "unpin" | "send" | "submit" | "upload" | "download" | "import" | "export" | "copy" | "approve" | "reject" | "cancel";
 /** The words of an action. */
 export interface ActionWords {
     /** "save", or with the object inside: "move {object} to the trash". */

package/dist/Interfaces/PreferenceInterfaces.d.ts

@@ -0,0 +1,43 @@
+/** The words of the app itself. Data keeps the language it was entered in. */
+export type InterfaceLanguage = "en" | "ne";
+/**
+ * The core's `ENumberScales`, by member value: where the groups of a number fall. `International` writes 1,234,567
+ * (thousand, million, billion); `SouthAsian` writes 12,34,567 (thousand, lakh, crore).
+ */
+export declare const ENumberScales: {
+    readonly International: 0;
+    readonly SouthAsian: 1;
+};
+export type ENumberScales = (typeof ENumberScales)[keyof typeof ENumberScales];
+/**
+ * The mark between groups of digits: 1,200, 1.200, 1 200 (a no-break space) or 1200. A period between the groups
+ * takes a comma for the decimal mark, as it does in much of Europe; every other choice keeps the period.
+ */
+export type ThousandsSeparator = "comma" | "period" | "space" | "none";
+export interface UserPreferences {
+    /** Default `en`. */
+    language: InterfaceLanguage;
+    /** Default `International`. */
+    numberScale: ENumberScales;
+    /** Default `comma`. */
+    thousands: ThousandsSeparator;
+    /**
+     * The rows every table opens with, over the size the table names itself, when the table offers it; a size picked in a
+     * table with a `stateKey` still wins there. `null` (the default): not chosen, each table's own.
+     */
+    pageSize: number | null;
+    /**
+     * A single click on a row opens its record (`true`) or only a double-click does (`false`), in every table, over what
+     * the table says itself. `null` (the default): not chosen, each table's own `openOnClick`.
+     */
+    rowClick: boolean | null;
+}
+export declare const DEFAULT_USER_PREFERENCES: UserPreferences;
+/** Local storage keys of the settings. A number scale is kept as its member value ("0", "1"), a row click as "1" or "0". */
+export declare const PREFERENCE_STORAGE_KEYS: {
+    readonly language: "nx-language";
+    readonly numberScale: "nx-number-scale";
+    readonly thousands: "nx-thousands";
+    readonly pageSize: "nx-page-size";
+    readonly rowClick: "nx-row-click";
+};

package/dist/Interfaces/PreferenceInterfaces.js

@@ -0,0 +1,28 @@
+/*
+ * The person's own settings beyond the theme and the dates: the interface language, how numbers are written, and what a
+ * table does before anyone touches its own controls. Saved on this device and read by the components that show them,
+ * so a change applies to everything on the page at once. The date settings are `DatePreferences` (DateInterfaces.ts).
+ */
+/**
+ * The core's `ENumberScales`, by member value: where the groups of a number fall. `International` writes 1,234,567
+ * (thousand, million, billion); `SouthAsian` writes 12,34,567 (thousand, lakh, crore).
+ */
+export const ENumberScales = {
+    International: 0,
+    SouthAsian: 1,
+};
+export const DEFAULT_USER_PREFERENCES = {
+    language: "en",
+    numberScale: ENumberScales.International,
+    thousands: "comma",
+    pageSize: null,
+    rowClick: null,
+};
+/** Local storage keys of the settings. A number scale is kept as its member value ("0", "1"), a row click as "1" or "0". */
+export const PREFERENCE_STORAGE_KEYS = {
+    language: "nx-language",
+    numberScale: "nx-number-scale",
+    thousands: "nx-thousands",
+    pageSize: "nx-page-size",
+    rowClick: "nx-row-click",
+};