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

package/dist/code/number-styles.js

@@ -0,0 +1,204 @@
+/**
+ * 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([
+ *   DotNetNumberStyleFlags.AllowLeadingSign,
+ *   DotNetNumberStyleFlags.AllowDecimalPoint,
+ *   DotNetNumberStyleFlags.AllowThousands
+ * ]);
+ * ```
+ *
+ * @public
+ * @category Number Styles
+ */
+export const DotNetNumberStyleFlags = {
+    /** Allow leading whitespace characters. */
+    allowLeadingWhite: 1,
+    /** Allow trailing whitespace characters. */
+    allowTrailingWhite: 2,
+    /** Allow a leading plus (+) or minus (-) sign. */
+    allowLeadingSign: 4,
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    allowTrailingSign: 8,
+    /** Allow parentheses to indicate negative numbers. */
+    allowParentheses: 16,
+    /** Allow decimal point in the number string. */
+    allowDecimalPoint: 32,
+    /** Allow thousands separator characters. */
+    allowThousands: 64,
+    /** Allow exponential notation (e.g., 1.23e+10). */
+    allowExponent: 128,
+    /** Allow currency symbol in the number string. */
+    allowCurrencySymbol: 256,
+    /** Parse the number as hexadecimal. */
+    allowHexSpecifier: 512,
+};
+/**
+ * Predefined number style combinations for common parsing scenarios.
+ *
+ * @example
+ * ```typescript
+ * // Use predefined style
+ * formatter.styles = DotNetNumberStyles.number;
+ * formatter.tryFromString('1,234.56');  // Parses successfully
+ *
+ * // Use currency style
+ * formatter.styles = DotNetNumberStyles.currency;
+ * formatter.tryFromString('$1,234.56');  // Parses successfully
+ * ```
+ *
+ * @public
+ * @category Number Styles
+ */
+export const DotNetNumberStyles = {
+    /** No styles - only basic digits allowed. */
+    none: 0,
+    allowLeadingWhite: DotNetNumberStyleFlags.allowLeadingWhite,
+    /** Allow trailing whitespace characters. */
+    allowTrailingWhite: DotNetNumberStyleFlags.allowTrailingWhite,
+    /** Allow a leading plus (+) or minus (-) sign. */
+    allowLeadingSign: DotNetNumberStyleFlags.allowLeadingSign,
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    allowTrailingSign: DotNetNumberStyleFlags.allowTrailingSign,
+    /** Allow parentheses to indicate negative numbers. */
+    allowParentheses: DotNetNumberStyleFlags.allowParentheses,
+    /** Allow decimal point in the number string. */
+    allowDecimalPoint: DotNetNumberStyleFlags.allowDecimalPoint,
+    /** Allow thousands separator characters. */
+    allowThousands: DotNetNumberStyleFlags.allowThousands,
+    /** Allow exponential notation (e.g., 1.23e+10). */
+    allowExponent: DotNetNumberStyleFlags.allowExponent,
+    /** Allow currency symbol in the number string. */
+    allowCurrencySymbol: DotNetNumberStyleFlags.allowCurrencySymbol,
+    /** Parse the number as hexadecimal. */
+    allowHexSpecifier: DotNetNumberStyleFlags.allowHexSpecifier,
+    /**
+     * All styles allowed (except hex).
+     * Includes: AllowCurrencySymbol, AllowDecimalPoint, AllowExponent, AllowLeadingSign,
+     * AllowLeadingWhite, AllowParentheses, AllowThousands, AllowTrailingSign, AllowTrailingWhite.
+     */
+    any: DotNetNumberStyleFlags.allowCurrencySymbol |
+        DotNetNumberStyleFlags.allowDecimalPoint |
+        DotNetNumberStyleFlags.allowExponent |
+        DotNetNumberStyleFlags.allowLeadingSign |
+        DotNetNumberStyleFlags.allowLeadingWhite |
+        DotNetNumberStyleFlags.allowParentheses |
+        DotNetNumberStyleFlags.allowThousands |
+        DotNetNumberStyleFlags.allowTrailingSign |
+        DotNetNumberStyleFlags.allowTrailingWhite,
+    /**
+     * Currency parsing style.
+     * Includes: AllowCurrencySymbol, AllowDecimalPoint, AllowLeadingSign, AllowLeadingWhite,
+     * AllowParentheses, AllowThousands, AllowTrailingSign, AllowTrailingWhite.
+     */
+    currency: DotNetNumberStyleFlags.allowCurrencySymbol |
+        DotNetNumberStyleFlags.allowDecimalPoint |
+        DotNetNumberStyleFlags.allowLeadingSign |
+        DotNetNumberStyleFlags.allowLeadingWhite |
+        DotNetNumberStyleFlags.allowParentheses |
+        DotNetNumberStyleFlags.allowThousands |
+        DotNetNumberStyleFlags.allowTrailingSign |
+        DotNetNumberStyleFlags.allowTrailingWhite,
+    /**
+     * Floating-point parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign,
+     * AllowDecimalPoint, AllowExponent.
+     */
+    float: DotNetNumberStyleFlags.allowLeadingWhite |
+        DotNetNumberStyleFlags.allowTrailingWhite |
+        DotNetNumberStyleFlags.allowLeadingSign |
+        DotNetNumberStyleFlags.allowDecimalPoint |
+        DotNetNumberStyleFlags.allowExponent,
+    /**
+     * Hexadecimal parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowHexSpecifier.
+     */
+    hexNumber: DotNetNumberStyleFlags.allowLeadingWhite |
+        DotNetNumberStyleFlags.allowTrailingWhite |
+        DotNetNumberStyleFlags.allowHexSpecifier,
+    /**
+     * Basic integer parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign.
+     */
+    integer: DotNetNumberStyleFlags.allowLeadingWhite |
+        DotNetNumberStyleFlags.allowTrailingWhite |
+        DotNetNumberStyleFlags.allowLeadingSign,
+    /**
+     * Standard number parsing style.
+     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign, AllowTrailingSign,
+     * AllowDecimalPoint, AllowThousands.
+     */
+    number: DotNetNumberStyleFlags.allowLeadingWhite |
+        DotNetNumberStyleFlags.allowTrailingWhite |
+        DotNetNumberStyleFlags.allowLeadingSign |
+        DotNetNumberStyleFlags.allowTrailingSign |
+        DotNetNumberStyleFlags.allowDecimalPoint |
+        DotNetNumberStyleFlags.allowThousands,
+};
+// /** @internal */
+// export class DotNetNumberStylesInfo {
+//   static toString(styles: DotNetNumberStyleFlags): string {
+//     return this.toXmlValue(styles);
+//   }
+//   static toXmlValue(styles: DotNetNumberStyleFlags): string {
+//     if (isSameSet(styles, DotNetNumberStyles.any)) return "Any";
+//     if (isSameSet(styles, DotNetNumberStyles.currency)) return "Currency";
+//     if (isSameSet(styles, DotNetNumberStyles.float)) return "Float";
+//     if (isSameSet(styles, DotNetNumberStyles.hexNumber)) return "HexNumber";
+//     if (isSameSet(styles, DotNetNumberStyles.integer)) return "Integer";
+//     if (isSameSet(styles, DotNetNumberStyles.number)) return "Number";
+//     return CommaText.fromStringArray(Array.from(styles.values()));
+//   }
+//   static tryFromString(value: string): Result<DotNetNumberStyleFlags> {
+//     return this.tryFromXmlValue(value);
+//   }
+//   static tryFromXmlValue(value: string): Result<DotNetNumberStyleFlags> {
+//     const normalized = value.trim();
+//     if (normalized.length === 0 || normalized.toLowerCase() === "none") {
+//       return new Ok(new Set(DotNetNumberStyles.none));
+//     }
+//     const canonical = normalized.toLowerCase();
+//     if (canonical === "any") return new Ok(new Set(DotNetNumberStyles.any));
+//     if (canonical === "currency")
+//       return new Ok(new Set(DotNetNumberStyles.currency));
+//     if (canonical === "float") return new Ok(new Set(DotNetNumberStyles.float));
+//     if (canonical === "hexnumber")
+//       return new Ok(new Set(DotNetNumberStyles.hexNumber));
+//     if (canonical === "integer")
+//       return new Ok(new Set(DotNetNumberStyles.integer));
+//     if (canonical === "number")
+//       return new Ok(new Set(DotNetNumberStyles.number));
+//     const commaTextResult = CommaText.tryToStringArray(normalized);
+//     if (commaTextResult.isErr()) {
+//       return commaTextResult.createOuter(
+//         "Invalid comma-separated styles string",
+//       );
+//     }
+//     const result = new Set<DotNetNumberStyleFlags>();
+//     for (const part of commaTextResult.value) {
+//       const match = Object.values(DotNetNumberStyleFlags).find(
+//         (x) => x.toLowerCase() === part.toLowerCase(),
+//       );
+//       if (match === undefined) {
+//         return new Err(`Invalid style: ${part}`);
+//       }
+//       result.add(match);
+//     }
+//     return new Ok(result);
+//   }
+//   static tryFromXmlValueWithDefault(
+//     value: string,
+//     defaultStyles: DotNetNumberStyleFlags,
+//   ): Result<DotNetNumberStyleFlags> {
+//     if (value.trim().length === 0) {
+//       return new Ok(new Set(defaultStyles));
+//     }
+//     return this.tryFromXmlValue(value);
+//   }
+// }
+//# sourceMappingURL=number-styles.js.map

package/dist/code/number-styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-styles.js","sourceRoot":"","sources":["../../src/code/number-styles.ts"],"names":[],"mappings":"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"}

package/dist/types/dot-net-date-number-formatting-untrimmed.d.ts

@@ -33,16 +33,29 @@ import { Result } from '@pbkware/js-utils';
  */
 export declare class DotNetDateTimeFormatter {
     /**
-     * Set of date/time style flags that are not currently supported by this implementation.
+     * Array of date/time style flags that are not currently supported by this implementation.
      * Operations using these styles will fail.
      */
-    static readonly unsupportedStyles: Set<DotNetDateTimeStyleId>;
+    static readonly unsupportedStyles: (16 | 32 | 64 | 128)[];
     private format;
     /**
-     * The set of {@link DotNetDateTimeStyleId} flags that control date/time parsing behavior.
-     * Currently only used for future parsing functionality.
+     * The {@link (DotNetDateTimeStyles:type)} flags that control date/time parsing behavior.
+     *
+     * Use predefined combinations from {@link (DotNetDateTimeStyles:variable)} or combine
+     * {@link (DotNetDateTimeStyleFlags:variable)} using bitwise OR.
+     *
+     * @example
+     * ```typescript
+     * // Use predefined combination
+     * formatter.styles = DotNetDateTimeStyles.allowWhiteSpaces;
+     *
+     * // Combine individual flags
+     * formatter.styles =
+     *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+     *   DotNetDateTimeStyleFlags.allowTrailingWhite;
+     * ```
      */
-    styles: DotNetDateTimeStyleSet;
+    styles: DotNetDateTimeStyles;
     /**
      * The locale settings that determine date/time separators and formatting conventions.
      */
@@ -103,70 +116,105 @@ export declare class DotNetDateTimeFormatter {
 /**
  * Individual style flags that control date/time parsing behavior.
  *
- * These flags can be combined to create custom parsing rules.
+ * These flags can be combined using bitwise OR to create custom parsing rules.
  *
  * @example
  * ```typescript
- * // Combine individual flags
- * formatter.styles = new Set([
- *   DotNetDateTimeStyleId.AllowLeadingWhite,
- *   DotNetDateTimeStyleId.AllowTrailingWhite
- * ]);
+ * const formatter = new DotNetDateTimeFormatter();
+ *
+ * // Combine multiple flags using bitwise OR
+ * formatter.styles =
+ *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+ *   DotNetDateTimeStyleFlags.allowTrailingWhite;
  * ```
  *
  * @public
  * @category DateTime Styles
  */
-export declare enum DotNetDateTimeStyleId {
+export declare const DotNetDateTimeStyleFlags: {
     /** Allow leading whitespace characters. */
-    AllowLeadingWhite = "AllowLeadingWhite",
+    readonly allowLeadingWhite: 1;
     /** Allow trailing whitespace characters. */
-    AllowTrailingWhite = "AllowTrailingWhite",
+    readonly allowTrailingWhite: 2;
     /** Allow whitespace within the date/time string. */
-    AllowInnerWhite = "AllowInnerWhite",
+    readonly allowInnerWhite: 4;
     /** Do not use current date for missing date components. */
-    NoCurrentDateDefault = "NoCurrentDateDefault",
+    readonly noCurrentDateDefault: 8;
     /** Adjust date/time to UTC (not implemented). */
-    AdjustToUniversal = "AdjustToUniversal",
+    readonly adjustToUniversal: 16;
     /** Assume local time zone if not specified (not implemented). */
-    AssumeLocal = "AssumeLocal",
+    readonly assumeLocal: 32;
     /** Assume UTC time zone if not specified (not implemented). */
-    AssumeUniversal = "AssumeUniversal",
+    readonly assumeUniversal: 64;
     /** Preserve DateTimeKind when parsing (not implemented). */
-    RoundTripKind = "RoundTripKind"
-}
+    readonly roundTripKind: 128;
+};
+
+/**
+ * The type representing possible values of {@link (DotNetDateTimeStyleFlags:variable)}.
+ *
+ * Flags can be combined using bitwise OR to create custom parsing behaviors.
+ *
+ * @public
+ * @category DateTime Styles
+ */
+export declare type DotNetDateTimeStyleFlags = (typeof DotNetDateTimeStyleFlags)[keyof typeof DotNetDateTimeStyleFlags];
 
 /**
  * Predefined date/time style combinations for common parsing scenarios.
  *
- * @internal
+ * Contains individual {@link (DotNetDateTimeStyleFlags:variable)} as well as common combinations.
+ *
+ * @example
+ * ```typescript
+ * const formatter = new DotNetDateTimeFormatter();
+ *
+ * // Use a predefined combination
+ * formatter.styles = DotNetDateTimeStyles.allowWhiteSpaces;
+ *
+ * // Or use individual flags
+ * formatter.styles = DotNetDateTimeStyles.allowLeadingWhite;
+ *
+ * // Or combine flags manually
+ * formatter.styles =
+ *   DotNetDateTimeStyleFlags.allowLeadingWhite |
+ *   DotNetDateTimeStyleFlags.noCurrentDateDefault;
+ * ```
+ *
  * @category DateTime Styles
+ * @public
  */
 export declare const DotNetDateTimeStyles: {
     /** No styles - strict parsing. */
-    none: Set<DotNetDateTimeStyleId>;
+    readonly none: 0;
+    readonly allowLeadingWhite: 1;
+    readonly allowTrailingWhite: 2;
+    readonly allowInnerWhite: 4;
     /**
      * Allow whitespace in date/time strings.
-     * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowInnerWhite.
+     * Includes: allowLeadingWhite, allowTrailingWhite, allowInnerWhite.
      */
-    allowWhiteSpaces: Set<DotNetDateTimeStyleId>;
+    readonly allowWhiteSpaces: number;
+    readonly noCurrentDateDefault: 8;
+    /** Adjust date/time to UTC (not implemented). */
+    readonly adjustToUniversal: 16;
+    /** Assume local time zone if not specified (not implemented). */
+    readonly assumeLocal: 32;
+    /** Assume UTC time zone if not specified (not implemented). */
+    readonly assumeUniversal: 64;
+    /** Preserve DateTimeKind when parsing (not implemented). */
+    readonly roundTripKind: 128;
 };
 
 /**
- * A set of {@link DotNetDateTimeStyleId} flags.
+ * The type representing possible values of {@link (DotNetDateTimeStyles:variable)}.
+ *
+ * This includes individual {@link (DotNetDateTimeStyleFlags:variable)} and predefined combinations.
  *
  * @public
  * @category DateTime Styles
  */
-export declare type DotNetDateTimeStyleSet = Set<DotNetDateTimeStyleId>;
-
-/** @internal */
-export declare class DotNetDateTimeStylesInfo {
-    static toString(styles: DotNetDateTimeStyleSet): string;
-    static toXmlValue(styles: DotNetDateTimeStyleSet): string;
-    static tryFromString(value: string): Result<DotNetDateTimeStyleSet>;
-    static tryFromXmlValue(value: string): Result<DotNetDateTimeStyleSet>;
-}
+export declare type DotNetDateTimeStyles = (typeof DotNetDateTimeStyles)[keyof typeof DotNetDateTimeStyles];
 
 /**
  * Formatter for decimal numbers with high precision using .NET-compatible format strings.
@@ -602,21 +650,14 @@ export declare class DotNetNumberFormatter {
     private precision;
     private sections;
     /**
-     * The set of {@link DotNetNumberStyleId} flags that control which number formats are allowed during parsing.
+     * The {@link (DotNetNumberStyles:variable)} 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
-     * ]);
+     * formatter.styles = DotNetNumberStyles.allowLeadingSign | DotNetNumberStyles.allowDecimalPoint;
      * ```
      */
-    styles: DotNetNumberStyleSet;
+    styles: DotNetNumberStyles;
     /**
      * The locale settings that determine decimal/thousands separators and other culture-specific formatting.
      */
@@ -687,37 +728,45 @@ export declare class DotNetNumberFormatter {
  * ```typescript
  * // Combine individual flags
  * formatter.styles = new Set([
- *   DotNetNumberStyleId.AllowLeadingSign,
- *   DotNetNumberStyleId.AllowDecimalPoint,
- *   DotNetNumberStyleId.AllowThousands
+ *   DotNetNumberStyleFlags.AllowLeadingSign,
+ *   DotNetNumberStyleFlags.AllowDecimalPoint,
+ *   DotNetNumberStyleFlags.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",
+export declare const DotNetNumberStyleFlags: {
     /** Allow leading whitespace characters. */
-    AllowLeadingWhite = "AllowLeadingWhite",
+    readonly allowLeadingWhite: 1;
+    /** Allow trailing whitespace characters. */
+    readonly allowTrailingWhite: 2;
+    /** Allow a leading plus (+) or minus (-) sign. */
+    readonly allowLeadingSign: 4;
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    readonly allowTrailingSign: 8;
     /** Allow parentheses to indicate negative numbers. */
-    AllowParentheses = "AllowParentheses",
+    readonly allowParentheses: 16;
+    /** Allow decimal point in the number string. */
+    readonly allowDecimalPoint: 32;
     /** Allow thousands separator characters. */
-    AllowThousands = "AllowThousands",
-    /** Allow a trailing plus (+) or minus (-) sign. */
-    AllowTrailingSign = "AllowTrailingSign",
-    /** Allow trailing whitespace characters. */
-    AllowTrailingWhite = "AllowTrailingWhite"
-}
+    readonly allowThousands: 64;
+    /** Allow exponential notation (e.g., 1.23e+10). */
+    readonly allowExponent: 128;
+    /** Allow currency symbol in the number string. */
+    readonly allowCurrencySymbol: 256;
+    /** Parse the number as hexadecimal. */
+    readonly allowHexSpecifier: 512;
+};
+
+/**
+ * A set of {@link (DotNetNumberStyleFlags:variable)} flags.
+ *
+ * @public
+ * @category Number Styles
+ */
+export declare type DotNetNumberStyleFlags = (typeof DotNetNumberStyleFlags)[keyof typeof DotNetNumberStyleFlags];
 
 /**
  * Predefined number style combinations for common parsing scenarios.
@@ -733,63 +782,75 @@ export declare enum DotNetNumberStyleId {
  * formatter.tryFromString('$1,234.56');  // Parses successfully
  * ```
  *
- * @internal
+ * @public
  * @category Number Styles
  */
 export declare const DotNetNumberStyles: {
     /** No styles - only basic digits allowed. */
-    none: Set<DotNetNumberStyleId>;
+    readonly none: 0;
+    readonly allowLeadingWhite: 1;
+    /** Allow trailing whitespace characters. */
+    readonly allowTrailingWhite: 2;
+    /** Allow a leading plus (+) or minus (-) sign. */
+    readonly allowLeadingSign: 4;
+    /** Allow a trailing plus (+) or minus (-) sign. */
+    readonly allowTrailingSign: 8;
+    /** Allow parentheses to indicate negative numbers. */
+    readonly allowParentheses: 16;
+    /** Allow decimal point in the number string. */
+    readonly allowDecimalPoint: 32;
+    /** Allow thousands separator characters. */
+    readonly allowThousands: 64;
+    /** Allow exponential notation (e.g., 1.23e+10). */
+    readonly allowExponent: 128;
+    /** Allow currency symbol in the number string. */
+    readonly allowCurrencySymbol: 256;
+    /** Parse the number as hexadecimal. */
+    readonly allowHexSpecifier: 512;
     /**
      * All styles allowed (except hex).
      * Includes: AllowCurrencySymbol, AllowDecimalPoint, AllowExponent, AllowLeadingSign,
      * AllowLeadingWhite, AllowParentheses, AllowThousands, AllowTrailingSign, AllowTrailingWhite.
      */
-    any: Set<DotNetNumberStyleId>;
+    readonly any: number;
     /**
      * Currency parsing style.
      * Includes: AllowCurrencySymbol, AllowDecimalPoint, AllowLeadingSign, AllowLeadingWhite,
      * AllowParentheses, AllowThousands, AllowTrailingSign, AllowTrailingWhite.
      */
-    currency: Set<DotNetNumberStyleId>;
+    readonly currency: number;
     /**
      * Floating-point parsing style.
      * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign,
      * AllowDecimalPoint, AllowExponent.
      */
-    float: Set<DotNetNumberStyleId>;
+    readonly float: number;
     /**
      * Hexadecimal parsing style.
      * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowHexSpecifier.
      */
-    hexNumber: Set<DotNetNumberStyleId>;
+    readonly hexNumber: number;
     /**
      * Basic integer parsing style.
      * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign.
      */
-    integer: Set<DotNetNumberStyleId>;
+    readonly integer: number;
     /**
      * Standard number parsing style.
      * Includes: AllowLeadingWhite, AllowTrailingWhite, AllowLeadingSign, AllowTrailingSign,
      * AllowDecimalPoint, AllowThousands.
      */
-    number: Set<DotNetNumberStyleId>;
+    readonly number: number;
 };
 
 /**
- * A set of {@link DotNetNumberStyleId} flags.
+ * The type representing possible values of {@link (DotNetNumberStyles:variable)}.
+ *
+ * This includes individual {@link (DotNetNumberStyleFlags:variable)} and predefined combinations.
  *
  * @public
  * @category Number Styles
  */
-export declare type DotNetNumberStyleSet = Set<DotNetNumberStyleId>;
-
-/** @internal */
-export declare class DotNetNumberStylesInfo {
-    static toString(styles: DotNetNumberStyleSet): string;
-    static toXmlValue(styles: DotNetNumberStyleSet): string;
-    static tryFromString(value: string): Result<DotNetNumberStyleSet>;
-    static tryFromXmlValue(value: string): Result<DotNetNumberStyleSet>;
-    static tryFromXmlValueWithDefault(value: string, defaultStyles: DotNetNumberStyleSet): Result<DotNetNumberStyleSet>;
-}
+export declare type DotNetNumberStyles = (typeof DotNetNumberStyles)[keyof typeof DotNetNumberStyles];
 
 export { }