@pbkware/dot-net-date-number-formatting 0.2.0

package/dist/types/public-api.d.ts

@@ -0,0 +1,714 @@
+import { Result } from '@pbkware/js-utils';
+
+/**
+ * Formatter for dates and times using .NET-compatible format strings.
+ *
+ * Supports both standard format strings (d, D, f, F, g, G, M, O, s, t, T, u, Y) and
+ * custom format strings with specific date/time components (yyyy, MM, dd, HH, mm, ss, etc.).
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetDateTimeFormatter();
+ * formatter.localeSettings = DotNetLocaleSettings.createInvariant();
+ *
+ * // Standard format strings
+ * formatter.trySetFormat('d');  // Short date
+ * console.log(formatter.toString(new Date(2024, 6, 5)));  // "7/5/2024"
+ *
+ * formatter.trySetFormat('F');  // Full date/time
+ * console.log(formatter.toString(new Date(2024, 6, 5, 14, 30, 0)));
+ * // "Friday, July 5, 2024 2:30:00 PM"
+ *
+ * // Custom format strings
+ * formatter.trySetFormat('yyyy-MM-dd');
+ * console.log(formatter.toString(new Date(2024, 6, 5)));  // "2024-07-05"
+ *
+ * formatter.trySetFormat("dddd, MMMM d 'at' h:mm tt");
+ * console.log(formatter.toString(new Date(2024, 6, 5, 14, 30, 0)));
+ * // "Friday, July 5 at 2:30 PM"
+ * ```
+ *
+ * @public
+ * @category DateTime Formatting
+ */
+export declare class DotNetDateTimeFormatter {
+    /**
+     * Set of date/time style flags that are not currently supported by this implementation.
+     * Operations using these styles will fail.
+     */
+    static readonly unsupportedStyles: Set<DotNetDateTimeStyleId>;
+    private format;
+    /**
+     * The set of {@link DotNetDateTimeStyleId} flags that control date/time parsing behavior.
+     * Currently only used for future parsing functionality.
+     */
+    styles: DotNetDateTimeStyleSet;
+    /**
+     * The locale settings that determine date/time separators and formatting conventions.
+     */
+    localeSettings: DotNetLocaleSettings;
+    private formatIsStandard;
+    private elements;
+    /**
+     * Contains the error message from the last failed operation.
+     * Check this property if {@link DotNetDateTimeFormatter.trySetFormat} returns an error.
+     */
+    parseErrorText: string;
+    /**
+     * Sets the format string to use for formatting dates and times.
+     *
+     * The format string is tokenized to confirm validity and to optimize formatting/parsing operations.
+     *
+     * @param value - A standard format string (single character like 'd', 'F', 'o') or
+     *                custom format string (e.g., "yyyy-MM-dd HH:mm:ss").
+     * @returns A Result indicating success or containing an error message if the format string is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Standard format
+     * formatter.trySetFormat('d');  // Short date
+     *
+     * // Custom format
+     * formatter.trySetFormat('yyyy-MM-dd HH:mm:ss');
+     *
+     * // Check for errors
+     * const result = formatter.trySetFormat('');
+     * if (result.isErr()) {
+     *   console.error(result.error);  // "Format text cannot be empty"
+     * }
+     * ```
+     */
+    trySetFormat(value: string): Result<void>;
+    /**
+     * Formats a Date using the current format string.
+     *
+     * @param value - The Date to format.
+     * @returns The formatted date/time string.
+     *
+     * @example
+     * ```typescript
+     * const date = new Date(2024, 6, 5, 14, 30, 45);
+     *
+     * formatter.trySetFormat('d');
+     * console.log(formatter.toString(date));  // "7/5/2024"
+     *
+     * formatter.trySetFormat('yyyy-MM-dd HH:mm:ss');
+     * console.log(formatter.toString(date));  // "2024-07-05 14:30:45"
+     * ```
+     */
+    toString(value: Date): string;
+    tryFromString(strValue: string): Result<Date>;
+}
+
+/**
+ * Individual style flags that control date/time parsing behavior.
+ *
+ * These flags can be combined to create custom parsing rules.
+ *
+ * @example
+ * ```typescript
+ * // Combine individual flags
+ * formatter.styles = new Set([
+ *   DotNetDateTimeStyleId.AllowLeadingWhite,
+ *   DotNetDateTimeStyleId.AllowTrailingWhite
+ * ]);
+ * ```
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export declare enum DotNetDateTimeStyleId {
+    /** Allow leading whitespace characters. */
+    AllowLeadingWhite = "AllowLeadingWhite",
+    /** Allow trailing whitespace characters. */
+    AllowTrailingWhite = "AllowTrailingWhite",
+    /** Allow whitespace within the date/time string. */
+    AllowInnerWhite = "AllowInnerWhite",
+    /** Do not use current date for missing date components. */
+    NoCurrentDateDefault = "NoCurrentDateDefault",
+    /** Adjust date/time to UTC (not implemented). */
+    AdjustToUniversal = "AdjustToUniversal",
+    /** Assume local time zone if not specified (not implemented). */
+    AssumeLocal = "AssumeLocal",
+    /** Assume UTC time zone if not specified (not implemented). */
+    AssumeUniversal = "AssumeUniversal",
+    /** Preserve DateTimeKind when parsing (not implemented). */
+    RoundTripKind = "RoundTripKind"
+}
+
+/* Excluded from this release type: DotNetDateTimeStyles */
+
+/**
+ * A set of {@link DotNetDateTimeStyleId} flags.
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export declare type DotNetDateTimeStyleSet = Set<DotNetDateTimeStyleId>;
+
+/* Excluded from this release type: DotNetDateTimeStylesInfo */
+
+/**
+ * Formatter for decimal numbers with high precision using .NET-compatible format strings.
+ *
+ * Similar to {@link DotNetFloatFormatter} but with different default precision behavior.
+ * When no format is specified, trailing zeros after the decimal point are automatically trimmed.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetDecimalFormatter();
+ * formatter.localeSettings = DotNetLocaleSettings.createInvariant();
+ *
+ * // High precision formatting
+ * formatter.trySetFormat('F6');
+ * console.log(formatter.toString(123.456));  // "123.456000"
+ *
+ * // Default behavior (trims trailing zeros)
+ * console.log(formatter.toString(123.400));  // "123.4"
+ * ```
+ *
+ * @public
+ * @category Numeric Formatting
+ */
+export declare class DotNetDecimalFormatter extends DotNetNumberFormatter {
+    /**
+     * Formats a number using the current format string.
+     * When no format is specified, trailing zeros are trimmed.
+     *
+     * @param value - The number to format.
+     * @returns The formatted number string.
+     */
+    toString(value: number): string;
+    /**
+     * Attempts to parse a number from a string using the current parsing styles.
+     *
+     * @param strValue - The string to parse.
+     * @returns A Result containing the parsed number if successful, or an error if parsing fails.
+     */
+    tryFromString(strValue: string): Result<number>;
+}
+
+/**
+ * Formatter for floating-point numbers using .NET-compatible format strings.
+ *
+ * Supports all standard numeric format strings (C, D, E, F, G, N, P, R, X, B) and
+ * custom format strings with digit placeholders, separators, and sections.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetFloatFormatter();
+ * formatter.localeSettings = DotNetLocaleSettings.createInvariant();
+ *
+ * // Currency format
+ * formatter.trySetFormat('C2');
+ * console.log(formatter.toString(1234.56));  // "$1,234.56"
+ *
+ * // Percentage format
+ * formatter.trySetFormat('P1');
+ * console.log(formatter.toString(0.1234));  // "12.3%"
+ *
+ * // Custom format with sections
+ * formatter.trySetFormat('#,##0.00;(#,##0.00)');
+ * console.log(formatter.toString(-1234.56));  // "(1,234.56)"
+ *
+ * // Parsing
+ * formatter.styles = DotNetNumberStyles.number;
+ * const result = formatter.tryFromString('1,234.56');
+ * if (result.isOk()) {
+ *   console.log(result.value);  // 1234.56
+ * }
+ * ```
+ *
+ * @public
+ * @category Numeric Formatting
+ */
+export declare class DotNetFloatFormatter extends DotNetNumberFormatter {
+    /**
+     * Formats a number using the current format string.
+     *
+     * @param value - The number to format.
+     * @returns The formatted number string.
+     */
+    toString(value: number): string;
+    /**
+     * Attempts to parse a number from a string using the current parsing styles.
+     *
+     * @param strValue - The string to parse.
+     * @returns A Result containing the parsed number if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * formatter.styles = DotNetNumberStyles.number;
+     * const result = formatter.tryFromString('  1,234.56  ');
+     * if (result.isOk()) {
+     *   console.log(result.value);  // 1234.56
+     * }
+     * ```
+     */
+    tryFromString(strValue: string): Result<number>;
+}
+
+/**
+ * Formatter for integer values (bigint) using .NET-compatible format strings.
+ *
+ * Supports formatting integers with standard format strings like D (decimal), X (hexadecimal),
+ * B (binary), and custom format strings.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetIntegerFormatter();
+ * formatter.localeSettings = DotNetLocaleSettings.createInvariant();
+ *
+ * // Decimal with padding
+ * formatter.trySetFormat('D8');
+ * console.log(formatter.toString(123n));  // "00000123"
+ *
+ * // Hexadecimal
+ * formatter.trySetFormat('X');
+ * console.log(formatter.toString(255n));  // "FF"
+ *
+ * // Parsing
+ * formatter.styles = DotNetNumberStyles.integer;
+ * const result = formatter.tryFromString('-12345');
+ * if (result.isOk()) {
+ *   console.log(result.value);  // -12345n
+ * }
+ * ```
+ *
+ * @public
+ * @category Numeric Formatting
+ */
+export declare class DotNetIntegerFormatter extends DotNetNumberFormatter {
+    /**
+     * Formats a bigint value using the current format string.
+     *
+     * @param value - The bigint value to format.
+     * @returns The formatted number string.
+     */
+    toString(value: bigint): string;
+    /**
+     * Attempts to parse a bigint value from a string using the current parsing styles.
+     *
+     * @param strValue - The string to parse.
+     * @returns A Result containing the parsed bigint if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * formatter.styles = DotNetNumberStyles.integer;
+     * const result = formatter.tryFromString('  -123  ');
+     * if (result.isOk()) {
+     *   console.log(result.value);  // -123n
+     * }
+     * ```
+     */
+    tryFromString(strValue: string): Result<bigint>;
+}
+
+/**
+ * Represents locale-specific formatting settings for dates, times, and numbers.
+ *
+ * Provides culture-specific separators and formatting options that determine how
+ * numbers, currencies, dates, and times are formatted and parsed.
+ *
+ * @example
+ * ```typescript
+ * // Use invariant culture (en-US)
+ * const invariant = DotNetLocaleSettings.createInvariant();
+ *
+ * // Use specific locale
+ * const french = DotNetLocaleSettings.create('fr-FR');
+ * console.log(french.decimalSeparator);  // ","
+ * console.log(french.thousandSeparator);  // " "
+ *
+ * // Use current system locale
+ * const current = DotNetLocaleSettings.current;
+ * ```
+ *
+ * @public
+ * @category Locale Settings
+ */
+export declare class DotNetLocaleSettings {
+    /**
+     * Singleton instance for invariant culture (en-US).
+     * Provides consistent formatting across all systems.
+     */
+    static readonly invariant: DotNetLocaleSettings;
+    /**
+     * Singleton instance for current system locale.
+     * Uses the locale settings from the runtime environment.
+     */
+    static readonly current: DotNetLocaleSettings;
+    /** The locale identifier (same as name). */
+    readonly id: string;
+    /** The locale name (e.g., "en-US", "fr-FR"). */
+    readonly name: string;
+    /** Character used for decimal point (e.g., "." or ","). */
+    readonly decimalSeparator: string;
+    /** Character used for thousands grouping (e.g., "," or "." or " "). */
+    readonly thousandSeparator: string;
+    /** Currency symbol for this locale (e.g., "$", "€", "£"). */
+    readonly currencyString: string;
+    /** Character used between date components (e.g., "/", "-", "."). */
+    readonly dateSeparator: string;
+    /** Character used between time components (typically ":"). */
+    readonly timeSeparator: string;
+    /** Pre-configured number formatter for floating-point values. */
+    readonly defaultFloat: Intl.NumberFormat;
+    /** Pre-configured number formatter for high-precision decimal values. */
+    readonly defaultDecimal: Intl.NumberFormat;
+    /** Pre-configured number formatter for currency values. */
+    readonly defaultCurrency: Intl.NumberFormat;
+    /**
+     * Creates a new DotNetLocaleSettings instance.
+     *
+     * @param localeName - Optional locale name (e.g., "en-US", "fr-FR").
+     *                     If undefined, uses the system's current locale.
+     *
+     * @example
+     * ```typescript
+     * // System locale
+     * const settings = new DotNetLocaleSettings(undefined);
+     *
+     * // Specific locale
+     * const french = new DotNetLocaleSettings('fr-FR');
+     * ```
+     */
+    constructor(localeName?: string);
+    /**
+     * Creates a DotNetLocaleSettings instance for the specified locale.
+     *
+     * @param localeName - The locale name (e.g., "en-US", "fr-FR", "de-DE").
+     * @returns A new DotNetLocaleSettings instance configured for the specified locale.
+     *
+     * @example
+     * ```typescript
+     * const usSettings = DotNetLocaleSettings.create('en-US');
+     * const frSettings = DotNetLocaleSettings.create('fr-FR');
+     * ```
+     */
+    static create(localeName: string): DotNetLocaleSettings;
+    /**
+     * Creates a DotNetLocaleSettings instance for the invariant culture (en-US).
+     * The invariant culture provides consistent formatting across all systems.
+     *
+     * @returns A new DotNetLocaleSettings instance configured for invariant culture.
+     *
+     * @example
+     * ```typescript
+     * const settings = DotNetLocaleSettings.createInvariant();
+     * console.log(settings.decimalSeparator);  // "."
+     * console.log(settings.thousandSeparator);  // ","
+     * ```
+     */
+    static createInvariant(): DotNetLocaleSettings;
+    /**
+     * Converts a number or bigint to a string using locale-specific formatting.
+     *
+     * @param value - The number or bigint to format.
+     * @param options - Optional Intl.NumberFormatOptions for custom formatting.
+     * @returns The formatted number string.
+     *
+     * @example
+     * ```typescript
+     * const settings = DotNetLocaleSettings.create('en-US');
+     * settings.numberToStr(1234.56);  // "1,234.56"
+     * settings.numberToStr(1234.56, { minimumFractionDigits: 2 });  // "1,234.56"
+     * ```
+     */
+    numberToStr(value: number | bigint, options?: Intl.NumberFormatOptions): string;
+    /**
+     * Converts a Date to a string using locale-specific formatting.
+     *
+     * @param value - The Date to format.
+     * @param options - Optional Intl.DateTimeFormatOptions for custom formatting.
+     * @returns The formatted date string.
+     *
+     * @example
+     * ```typescript
+     * const settings = DotNetLocaleSettings.create('en-US');
+     * settings.dateToStr(new Date(2024, 6, 5), { dateStyle: 'short' });  // "7/5/2024"
+     * ```
+     */
+    dateToStr(value: Date, options?: Intl.DateTimeFormatOptions): string;
+    /**
+     * Converts a boolean to a string.
+     *
+     * @param value - The boolean value.
+     * @returns "true" or "false".
+     *
+     * @example
+     * ```typescript
+     * settings.boolToStr(true);   // "true"
+     * settings.boolToStr(false);  // "false"
+     * ```
+     */
+    boolToStr(value: boolean): string;
+    /**
+     * Attempts to parse a boolean value from a string.
+     *
+     * @param value - The string to parse. Accepts: "true", "1", "yes" (case-insensitive) for true,
+     *                and "false", "0", "no" for false.
+     * @returns A Result containing the boolean value if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * settings.tryStrToBool('yes');    // Ok(true)
+     * settings.tryStrToBool('false');  // Ok(false)
+     * settings.tryStrToBool('invalid');  // Err("Invalid boolean string")
+     * ```
+     */
+    tryStrToBool(value: string): Result<boolean>;
+    /**
+     * Attempts to parse an integer from a string.
+     *
+     * @param value - The string to parse. Must contain only digits and an optional leading +/- sign.
+     * @returns A Result containing the parsed integer if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * settings.tryStrToInt('123');    // Ok(123)
+     * settings.tryStrToInt('-456');   // Ok(-456)
+     * settings.tryStrToInt('12.34');  // Err("Invalid integer string")
+     * ```
+     */
+    tryStrToInt(value: string): Result<number>;
+    /**
+     * Attempts to parse a BigInt from a string.
+     *
+     * @param value - The string to parse. Must contain only digits and an optional leading +/- sign.
+     * @returns A Result containing the parsed BigInt if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * settings.tryStrToBigInt('12345678901234567890');  // Ok(12345678901234567890n)
+     * settings.tryStrToBigInt('-999');  // Ok(-999n)
+     * ```
+     */
+    tryStrToBigInt(value: string): Result<bigint>;
+    /**
+     * Attempts to parse a number from a string using locale-specific formatting.
+     * Handles currency symbols, thousands separators, and locale-specific decimal separators.
+     *
+     * @param value - The string to parse.
+     * @returns A Result containing the parsed number if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * const usSettings = DotNetLocaleSettings.create('en-US');
+     * usSettings.tryStrToNumber('1,234.56');  // Ok(1234.56)
+     * usSettings.tryStrToNumber('$1,234.56');  // Ok(1234.56)
+     *
+     * const frSettings = DotNetLocaleSettings.create('fr-FR');
+     * frSettings.tryStrToNumber('1 234,56');  // Ok(1234.56)
+     * ```
+     */
+    tryStrToNumber(value: string): Result<number>;
+    /**
+     * Attempts to parse a Date from a string.
+     *
+     * @param value - The string to parse. Accepts various date formats understood by JavaScript Date constructor.
+     * @returns A Result containing the parsed Date if successful, or an error if parsing fails.
+     *
+     * @example
+     * ```typescript
+     * settings.tryStrToDate('2024-07-05');  // Ok(Date)
+     * settings.tryStrToDate('July 5, 2024');  // Ok(Date)
+     * settings.tryStrToDate('invalid');  // Err("Invalid date string")
+     * ```
+     */
+    tryStrToDate(value: string): Result<Date>;
+    /**
+     * Convert a single character to uppercase using culture-specific rules.
+     * Handles special cases like Turkish 'i' → 'İ' vs standard 'i' → 'I'.
+     *
+     * @param char - The character to convert to uppercase.
+     * @returns The uppercased character.
+     *
+     * @example
+     * ```typescript
+     * const usSettings = DotNetLocaleSettings.create('en-US');
+     * usSettings.toUpperChar('i');  // "I"
+     *
+     * const trSettings = DotNetLocaleSettings.create('tr-TR');
+     * trSettings.toUpperChar('i');  // "İ" (Turkish dotted I)
+     * ```
+     */
+    toUpperChar(char: string): string;
+    /**
+     * Convert a single character to lowercase using culture-specific rules.
+     * Handles special cases like Turkish 'I' → 'ı' vs Turkish 'İ' → 'i'.
+     *
+     * @param char - The character to convert to lowercase.
+     * @returns The lowercased character.
+     *
+     * @example
+     * ```typescript
+     * const usSettings = DotNetLocaleSettings.create('en-US');
+     * usSettings.toLowerChar('I');  // "i"
+     *
+     * const trSettings = DotNetLocaleSettings.create('tr-TR');
+     * trSettings.toLowerChar('I');  // "ı" (Turkish dotless i)
+     * trSettings.toLowerChar('İ');  // "i" (Turkish dotted i)
+     * ```
+     */
+    toLowerChar(char: string): string;
+}
+
+/**
+ * Base class for formatting and parsing numbers using .NET-compatible format strings.
+ *
+ * Supports both standard format strings (C, D, E, F, G, N, P, R, X, B) and custom format strings
+ * with fine-grained control over digit placeholders, separators, and sections.
+ *
+ * @remarks
+ * This is a base class - use {@link DotNetIntegerFormatter}, {@link DotNetFloatFormatter},
+ * or {@link DotNetDecimalFormatter} for specific number types.
+ *
+ * @example
+ * ```typescript
+ * // Use derived classes instead
+ * const formatter = new DotNetFloatFormatter();
+ * formatter.localeSettings = DotNetLocaleSettings.createInvariant();
+ * formatter.trySetFormat('C2');
+ * console.log(formatter.toString(1234.56));  // "$1,234.56"
+ * ```
+ *
+ * @public
+ * @category Numeric Formatting
+ */
+export declare class DotNetNumberFormatter {
+    protected format: string;
+    private formatIsStandard;
+    private precision;
+    private sections;
+    /**
+     * The set of {@link DotNetNumberStyleId} flags that control which number formats are allowed during parsing.
+     *
+     * @example
+     * ```typescript
+     * // Use predefined styles
+     * formatter.styles = DotNetNumberStyles.number;
+     *
+     * // Or combine individual flags
+     * formatter.styles = new Set([
+     *   DotNetNumberStyleId.AllowLeadingSign,
+     *   DotNetNumberStyleId.AllowDecimalPoint
+     * ]);
+     * ```
+     */
+    styles: DotNetNumberStyleSet;
+    /**
+     * The locale settings that determine decimal/thousands separators and other culture-specific formatting.
+     */
+    localeSettings: DotNetLocaleSettings;
+    /**
+     * Contains the error message from the last failed operation.
+     * Check this property if {@link DotNetNumberFormatter.trySetFormat} or parsing methods return an error.
+     */
+    parseErrorText: string;
+    protected setParseErrorText(value: string): false;
+    /**
+     * Sets the format string to use for formatting numbers.
+     *
+     * The format string is tokenized to confirm validity and to optimize formatting/parsing operations.
+     *
+     * @param value - A standard format string (e.g., "C", "N2", "E3") or custom format string (e.g., "#,##0.00").
+     * @returns A Result indicating success or containing an error message if the format string is invalid.
+     *
+     * @example
+     * ```typescript
+     * // Standard format
+     * formatter.trySetFormat('C2');  // Currency with 2 decimal places
+     *
+     * // Custom format
+     * formatter.trySetFormat('#,##0.00');  // Number with thousands separator
+     *
+     * // Check for errors
+     * const result = formatter.trySetFormat('INVALID');
+     * if (result.isErr()) {
+     *   console.error(result.error);
+     * }
+     * ```
+     */
+    trySetFormat(value: string): Result<void>;
+    private parseCustomFormat;
+    private analyzeSection;
+    protected formatNumber(value: number | bigint, allowDecimal?: boolean): string;
+    private formatStandard;
+    private formatCurrency;
+    private formatDecimal;
+    private formatExponential;
+    private formatFixedPoint;
+    private formatGeneral;
+    private formatNumber_;
+    private formatPercent;
+    private formatHex;
+    private formatBinary;
+    private formatCustom;
+    private formatWithSection;
+    private formatCustomExponential;
+    protected trimTrailingPadZeros(value: string): string;
+    hasExponentChar(value: string): boolean;
+    hasDecimalChar(value: string): boolean;
+    hasDigitChar(value: string): boolean;
+    static tryHexToInt64(hex: string): Result<bigint>;
+    protected unstyleNumberString(value: string): Result<{
+        unstyled: string;
+        negated: boolean;
+    }>;
+}
+
+/**
+ * Individual style flags that control which number formats are allowed during parsing.
+ *
+ * These flags can be combined to create custom parsing behavior.
+ *
+ * @example
+ * ```typescript
+ * // Combine individual flags
+ * formatter.styles = new Set([
+ *   DotNetNumberStyleId.AllowLeadingSign,
+ *   DotNetNumberStyleId.AllowDecimalPoint,
+ *   DotNetNumberStyleId.AllowThousands
+ * ]);
+ * ```
+ *
+ * @public
+ * @category Number Styles
+ */
+export declare enum DotNetNumberStyleId {
+    /** Allow currency symbol in the number string. */
+    AllowCurrencySymbol = "AllowCurrencySymbol",
+    /** Allow decimal point in the number string. */
+    AllowDecimalPoint = "AllowDecimalPoint",
+    /** Allow exponential notation (e.g., 1.23e+10). */
+    AllowExponent = "AllowExponent",
+    /** Parse the number as hexadecimal. */
+    AllowHexSpecifier = "AllowHexSpecifier",
+    /** Allow a leading plus (+) or minus (-) sign. */
+    AllowLeadingSign = "AllowLeadingSign",
+    /** Allow leading whitespace characters. */
+    AllowLeadingWhite = "AllowLeadingWhite",
+    /** Allow parentheses to indicate negative numbers. */
+    AllowParentheses = "AllowParentheses",
+    /** Allow thousands separator characters. */
+    AllowThousands = "AllowThousands",
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    AllowTrailingSign = "AllowTrailingSign",
+    /** Allow trailing whitespace characters. */
+    AllowTrailingWhite = "AllowTrailingWhite"
+}
+
+/* Excluded from this release type: DotNetNumberStyles */
+
+/**
+ * A set of {@link DotNetNumberStyleId} flags.
+ *
+ * @public
+ * @category Number Styles
+ */
+export declare type DotNetNumberStyleSet = Set<DotNetNumberStyleId>;
+
+/* Excluded from this release type: DotNetNumberStylesInfo */
+
+export { }