@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/text/DateFormatSymbols/index.d.ts

@@ -0,0 +1,290 @@
+import type { Locale } from "../../util/Locale";
+import type { String } from "../../lang/String";
+
+import type { Object } from "../../lang/Object";
+
+import type { Serializable } from "../../io/Serializable";
+import type { Cloneable } from "../../lang/Cloneable";
+
+/**
+ * <code>DateFormatSymbols</code> is a public class for encapsulating
+ *  localizable date-time formatting data, such as the names of the
+ *  months, the names of the days of the week, and the time zone data.
+ *  <code>SimpleDateFormat</code> uses
+ *  <code>DateFormatSymbols</code> to encapsulate this information.
+ *
+ *  <p>
+ *  Typically you shouldn't use <code>DateFormatSymbols</code> directly.
+ *  Rather, you are encouraged to create a date-time formatter with the
+ *  <code>DateFormat</code> class's factory methods: <code>getTimeInstance</code>,
+ *  <code>getDateInstance</code>, or <code>getDateTimeInstance</code>.
+ *  These methods automatically create a <code>DateFormatSymbols</code> for
+ *  the formatter so that you don't have to. After the
+ *  formatter is created, you may modify its format pattern using the
+ *  <code>setPattern</code> method. For more information about
+ *  creating formatters using <code>DateFormat</code>'s factory methods,
+ *  see {@link DateFormat}.
+ *
+ *  <p>
+ *  If you decide to create a date-time formatter with a specific
+ *  format pattern for a specific locale, you can do so with:
+ *  <blockquote>
+ *  <pre>
+ *  new SimpleDateFormat(aPattern, DateFormatSymbols.getInstance(aLocale)).
+ *  </pre>
+ *  </blockquote>
+ *
+ *  <p>
+ *  <code>DateFormatSymbols</code> objects are cloneable. When you obtain
+ *  a <code>DateFormatSymbols</code> object, feel free to modify the
+ *  date-time formatting data. For instance, you can replace the localized
+ *  date-time format pattern characters with the ones that you feel easy
+ *  to remember. Or you can change the representative cities
+ *  to your favorite ones.
+ *
+ *  <p>
+ *  New <code>DateFormatSymbols</code> subclasses may be added to support
+ *  <code>SimpleDateFormat</code> for date-time formatting for additional locales.
+ * @see DateFormat
+ * @see SimpleDateFormat
+ * @see java.util.SimpleTimeZone
+ * @author Chen-Lieh Huang
+ */
+export type DateFormatSymbols = Object &
+  Serializable &
+  Cloneable & {
+    /**
+     * Returns an array of all locales for which the
+     *  <code>getInstance</code> methods of this class can return
+     *  localized instances.
+     *  The returned array represents the union of locales supported by the
+     *  Java runtime and by installed
+     *  {@link java.text.spi.DateFormatSymbolsProvider DateFormatSymbolsProvider}
+     *  implementations.  It must contain at least a <code>Locale</code>
+     *  instance equal to {@link java.util.Locale#US Locale.US}.
+     * @return An array of locales for which localized&#xA; <code>DateFormatSymbols</code> instances are available.
+     * @since 1.6
+     */
+    getAvailableLocales(): Locale;
+
+    /**
+     * Gets the <code>DateFormatSymbols</code> instance for the default
+     *  locale.  This method provides access to <code>DateFormatSymbols</code>
+     *  instances for locales supported by the Java runtime itself as well
+     *  as for those supported by installed
+     *  {@link java.text.spi.DateFormatSymbolsProvider DateFormatSymbolsProvider}
+     *  implementations.
+     *  <p>This is equivalent to calling {@link #getInstance(Locale)
+     *      getInstance(Locale.getDefault(Locale.Category.FORMAT))}.
+     * @see java.util.Locale#getDefault(java.util.Locale.Category)
+     * @see java.util.Locale.Category#FORMAT
+     * @return a <code>DateFormatSymbols</code> instance.
+     * @since 1.6
+     */
+    getInstance(): DateFormatSymbols;
+
+    /**
+     * Gets the <code>DateFormatSymbols</code> instance for the specified
+     *  locale.  This method provides access to <code>DateFormatSymbols</code>
+     *  instances for locales supported by the Java runtime itself as well
+     *  as for those supported by installed
+     *  {@link java.text.spi.DateFormatSymbolsProvider DateFormatSymbolsProvider}
+     *  implementations.
+     * @param locale the given locale.
+     * @return a <code>DateFormatSymbols</code> instance.
+     * @throws NullPointerException if <code>locale</code> is null
+     * @since 1.6
+     */
+    getInstance(locale: Locale): DateFormatSymbols;
+
+    /**
+     * Gets era strings. For example: "AD" and "BC".
+     * @return the era strings.
+     */
+    getEras(): string;
+
+    /**
+     * Sets era strings. For example: "AD" and "BC".
+     * @param newEras the new era strings.
+     */
+    setEras(newEras: String | string[]): void;
+
+    /**
+     * Gets month strings. For example: "January", "February", etc.
+     *
+     *  <p>If the language requires different forms for formatting and
+     *  stand-alone usages, this method returns month names in the
+     *  formatting form. For example, the preferred month name for
+     *  January in the Czech language is <em>ledna</em> in the
+     *  formatting form, while it is <em>leden</em> in the stand-alone
+     *  form. This method returns {@code "ledna"} in this case. Refer
+     *  to the <a href="http://unicode.org/reports/tr35/#Calendar_Elements">
+     *  Calendar Elements in the Unicode Locale Data Markup Language
+     *  (LDML) specification</a> for more details.
+     * @return the month strings.
+     */
+    getMonths(): string;
+
+    /**
+     * Sets month strings. For example: "January", "February", etc.
+     * @param newMonths the new month strings.
+     */
+    setMonths(newMonths: String | string[]): void;
+
+    /**
+     * Gets short month strings. For example: "Jan", "Feb", etc.
+     *
+     *  <p>If the language requires different forms for formatting and
+     *  stand-alone usages, This method returns short month names in
+     *  the formatting form. For example, the preferred abbreviation
+     *  for January in the Catalan language is <em>de gen.</em> in the
+     *  formatting form, while it is <em>gen.</em> in the stand-alone
+     *  form. This method returns {@code "de gen."} in this case. Refer
+     *  to the <a href="http://unicode.org/reports/tr35/#Calendar_Elements">
+     *  Calendar Elements in the Unicode Locale Data Markup Language
+     *  (LDML) specification</a> for more details.
+     * @return the short month strings.
+     */
+    getShortMonths(): string;
+
+    /**
+     * Sets short month strings. For example: "Jan", "Feb", etc.
+     * @param newShortMonths the new short month strings.
+     */
+    setShortMonths(newShortMonths: String | string[]): void;
+
+    /**
+     * Gets weekday strings. For example: "Sunday", "Monday", etc.
+     * @return the weekday strings. Use <code>Calendar.SUNDAY</code>,&#xA; <code>Calendar.MONDAY</code>, etc. to index the result array.
+     */
+    getWeekdays(): string;
+
+    /**
+     * Sets weekday strings. For example: "Sunday", "Monday", etc.
+     * @param newWeekdays the new weekday strings. The array should&#xA; be indexed by <code>Calendar.SUNDAY</code>,&#xA; <code>Calendar.MONDAY</code>, etc.
+     */
+    setWeekdays(newWeekdays: String | string[]): void;
+
+    /**
+     * Gets short weekday strings. For example: "Sun", "Mon", etc.
+     * @return the short weekday strings. Use <code>Calendar.SUNDAY</code>,&#xA; <code>Calendar.MONDAY</code>, etc. to index the result array.
+     */
+    getShortWeekdays(): string;
+
+    /**
+     * Sets short weekday strings. For example: "Sun", "Mon", etc.
+     * @param newShortWeekdays the new short weekday strings. The array should&#xA; be indexed by <code>Calendar.SUNDAY</code>,&#xA; <code>Calendar.MONDAY</code>, etc.
+     */
+    setShortWeekdays(newShortWeekdays: String | string[]): void;
+
+    /**
+     * Gets ampm strings. For example: "AM" and "PM".
+     * @return the ampm strings.
+     */
+    getAmPmStrings(): string;
+
+    /**
+     * Sets ampm strings. For example: "AM" and "PM".
+     * @param newAmpms the new ampm strings.
+     */
+    setAmPmStrings(newAmpms: String | string[]): void;
+
+    /**
+     * Gets time zone strings.  Use of this method is discouraged; use
+     *  {@link java.util.TimeZone#getDisplayName() TimeZone.getDisplayName()}
+     *  instead.
+     *  <p>
+     *  The value returned is a
+     *  two-dimensional array of strings of size <em>n</em> by <em>m</em>,
+     *  where <em>m</em> is at least 5.  Each of the <em>n</em> rows is an
+     *  entry containing the localized names for a single <code>TimeZone</code>.
+     *  Each such row contains (with <code>i</code> ranging from
+     *  0..<em>n</em>-1):
+     *  <ul>
+     *  <li><code>zoneStrings[i][0]</code> - time zone ID</li>
+     *  <li><code>zoneStrings[i][1]</code> - long name of zone in standard
+     *  time</li>
+     *  <li><code>zoneStrings[i][2]</code> - short name of zone in
+     *  standard time</li>
+     *  <li><code>zoneStrings[i][3]</code> - long name of zone in daylight
+     *  saving time</li>
+     *  <li><code>zoneStrings[i][4]</code> - short name of zone in daylight
+     *  saving time</li>
+     *  </ul>
+     *  The zone ID is <em>not</em> localized; it's one of the valid IDs of
+     *  the {@link java.util.TimeZone TimeZone} class that are not
+     *  <a href="../util/TimeZone.html#CustomID">custom IDs</a>.
+     *  All other entries are localized names.  If a zone does not implement
+     *  daylight saving time, the daylight saving time names should not be used.
+     *  <p>
+     *  If {@link #setZoneStrings(String[][]) setZoneStrings} has been called
+     *  on this <code>DateFormatSymbols</code> instance, then the strings
+     *  provided by that call are returned. Otherwise, the returned array
+     *  contains names provided by the Java runtime and by installed
+     *  {@link java.util.spi.TimeZoneNameProvider TimeZoneNameProvider}
+     *  implementations.
+     * @return the time zone strings.
+     * @see #setZoneStrings(String[][])
+     */
+    getZoneStrings(): string;
+
+    /**
+     * Sets time zone strings.  The argument must be a
+     *  two-dimensional array of strings of size <em>n</em> by <em>m</em>,
+     *  where <em>m</em> is at least 5.  Each of the <em>n</em> rows is an
+     *  entry containing the localized names for a single <code>TimeZone</code>.
+     *  Each such row contains (with <code>i</code> ranging from
+     *  0..<em>n</em>-1):
+     *  <ul>
+     *  <li><code>zoneStrings[i][0]</code> - time zone ID</li>
+     *  <li><code>zoneStrings[i][1]</code> - long name of zone in standard
+     *  time</li>
+     *  <li><code>zoneStrings[i][2]</code> - short name of zone in
+     *  standard time</li>
+     *  <li><code>zoneStrings[i][3]</code> - long name of zone in daylight
+     *  saving time</li>
+     *  <li><code>zoneStrings[i][4]</code> - short name of zone in daylight
+     *  saving time</li>
+     *  </ul>
+     *  The zone ID is <em>not</em> localized; it's one of the valid IDs of
+     *  the {@link java.util.TimeZone TimeZone} class that are not
+     *  <a href="../util/TimeZone.html#CustomID">custom IDs</a>.
+     *  All other entries are localized names.
+     * @param newZoneStrings the new time zone strings.
+     * @throws IllegalArgumentException if the length of any row in&#xA; <code>newZoneStrings</code> is less than 5
+     * @throws NullPointerException if <code>newZoneStrings</code> is null
+     * @see #getZoneStrings()
+     */
+    setZoneStrings(newZoneStrings: String | string[][]): void;
+
+    /**
+     * Gets localized date-time pattern characters. For example: 'u', 't', etc.
+     * @return the localized date-time pattern characters.
+     */
+    getLocalPatternChars(): string;
+
+    /**
+     * Sets localized date-time pattern characters. For example: 'u', 't', etc.
+     * @param newLocalPatternChars the new localized date-time&#xA; pattern characters.
+     */
+    setLocalPatternChars(newLocalPatternChars: String | string): void;
+
+    /**
+ * Overrides Cloneable
+  
+    */
+    clone(): unknown;
+
+    /**
+ * Override hashCode.
+ *  Generates a hash code for the DateFormatSymbols object.
+  
+    */
+    hashCode(): number;
+
+    /**
+ * Override equals
+  
+    */
+    equals(obj: unknown): boolean;
+  };

package/types/java/text/DateFormatSymbols/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getAvailableLocales: function getAvailableLocales() {},
+  getInstance: function getInstance() {},
+  getEras: function getEras() {},
+  setEras: function setEras() {},
+  getMonths: function getMonths() {},
+  setMonths: function setMonths() {},
+  getShortMonths: function getShortMonths() {},
+  setShortMonths: function setShortMonths() {},
+  getWeekdays: function getWeekdays() {},
+  setWeekdays: function setWeekdays() {},
+  getShortWeekdays: function getShortWeekdays() {},
+  setShortWeekdays: function setShortWeekdays() {},
+  getAmPmStrings: function getAmPmStrings() {},
+  setAmPmStrings: function setAmPmStrings() {},
+  getZoneStrings: function getZoneStrings() {},
+  setZoneStrings: function setZoneStrings() {},
+  getLocalPatternChars: function getLocalPatternChars() {},
+  setLocalPatternChars: function setLocalPatternChars() {},
+  clone: function clone() {},
+  hashCode: function hashCode() {},
+  equals: function equals() {}
+};
+exports["default"] = _default;

package/types/java/text/FieldPosition/index.d.ts

@@ -0,0 +1,98 @@
+import type { Field } from "../Format.Field";
+
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+
+/**
+ * <code>FieldPosition</code> is a simple class used by <code>Format</code>
+ *  and its subclasses to identify fields in formatted output. Fields can
+ *  be identified in two ways:
+ *  <ul>
+ *   <li>By an integer constant, whose names typically end with
+ *       <code>_FIELD</code>. The constants are defined in the various
+ *       subclasses of <code>Format</code>.
+ *   <li>By a <code>Format.Field</code> constant, see <code>ERA_FIELD</code>
+ *       and its friends in <code>DateFormat</code> for an example.
+ *  </ul>
+ *  <p>
+ *  <code>FieldPosition</code> keeps track of the position of the
+ *  field within the formatted output with two indices: the index
+ *  of the first character of the field and the index of the last
+ *  character of the field.
+ *
+ *  <p>
+ *  One version of the <code>format</code> method in the various
+ *  <code>Format</code> classes requires a <code>FieldPosition</code>
+ *  object as an argument. You use this <code>format</code> method
+ *  to perform partial formatting or to get information about the
+ *  formatted output (such as the position of a field).
+ *
+ *  <p>
+ *  If you are interested in the positions of all attributes in the
+ *  formatted string use the <code>Format</code> method
+ *  <code>formatToCharacterIterator</code>.
+ * @author Mark Davis
+ * @see java.text.Format
+ */
+export type FieldPosition = Object & {
+  /**
+   * Returns the field identifier as an attribute constant
+   *  from one of the <code>Field</code> subclasses. May return null if
+   *  the field is specified only by an integer field ID.
+   * @return Identifier for the field
+   * @since 1.4
+   */
+  getFieldAttribute(): Field;
+
+  /**
+   * Retrieves the field identifier.
+   * @return the field identifier
+   */
+  getField(): number;
+
+  /**
+   * Retrieves the index of the first character in the requested field.
+   * @return the begin index
+   */
+  getBeginIndex(): number;
+
+  /**
+   * Retrieves the index of the character following the last character in the
+   *  requested field.
+   * @return the end index
+   */
+  getEndIndex(): number;
+
+  /**
+   * Sets the begin index.  For use by subclasses of Format.
+   * @param bi the begin index
+   * @since 1.2
+   */
+  setBeginIndex(bi: number): void;
+
+  /**
+   * Sets the end index.  For use by subclasses of Format.
+   * @param ei the end index
+   * @since 1.2
+   */
+  setEndIndex(ei: number): void;
+
+  /**
+ * Overrides equals
+  
+    */
+  equals(obj: unknown): boolean;
+
+  /**
+   * Returns a hash code for this FieldPosition.
+   * @return a hash code value for this object
+   */
+  hashCode(): number;
+
+  /**
+   * Return a string representation of this FieldPosition.
+   * @return a string representation of this object
+   */
+  toString(): string;
+};

package/types/java/text/FieldPosition/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getFieldAttribute: function getFieldAttribute() {},
+  getField: function getField() {},
+  getBeginIndex: function getBeginIndex() {},
+  getEndIndex: function getEndIndex() {},
+  setBeginIndex: function setBeginIndex() {},
+  setEndIndex: function setEndIndex() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/text/Format/index.d.ts

@@ -0,0 +1,190 @@
+import type { Object } from "../../lang/Object";
+import type { String } from "../../lang/String";
+import type { StringBuffer } from "../../lang/StringBuffer";
+import type { FieldPosition } from "../FieldPosition";
+import type { AttributedCharacterIterator } from "../AttributedCharacterIterator";
+import type { ParsePosition } from "../ParsePosition";
+import type { Serializable } from "../../io/Serializable";
+import type { Cloneable } from "../../lang/Cloneable";
+
+/**
+ * <code>Format</code> is an abstract base class for formatting locale-sensitive
+ *  information such as dates, messages, and numbers.
+ *
+ *  <p>
+ *  <code>Format</code> defines the programming interface for formatting
+ *  locale-sensitive objects into <code>String</code>s (the
+ *  <code>format</code> method) and for parsing <code>String</code>s back
+ *  into objects (the <code>parseObject</code> method).
+ *
+ *  <p>
+ *  Generally, a format's <code>parseObject</code> method must be able to parse
+ *  any string formatted by its <code>format</code> method. However, there may
+ *  be exceptional cases where this is not possible. For example, a
+ *  <code>format</code> method might create two adjacent integer numbers with
+ *  no separator in between, and in this case the <code>parseObject</code> could
+ *  not tell which digits belong to which number.
+ *
+ *  <h3>Subclassing</h3>
+ *
+ *  <p>
+ *  The Java Platform provides three specialized subclasses of <code>Format</code>--
+ *  <code>DateFormat</code>, <code>MessageFormat</code>, and
+ *  <code>NumberFormat</code>--for formatting dates, messages, and numbers,
+ *  respectively.
+ *  <p>
+ *  Concrete subclasses must implement three methods:
+ *  <ol>
+ *  <li> <code>format(Object obj, StringBuffer toAppendTo, FieldPosition pos)</code>
+ *  <li> <code>formatToCharacterIterator(Object obj)</code>
+ *  <li> <code>parseObject(String source, ParsePosition pos)</code>
+ *  </ol>
+ *  These general methods allow polymorphic parsing and formatting of objects
+ *  and are used, for example, by <code>MessageFormat</code>.
+ *  Subclasses often also provide additional <code>format</code> methods for
+ *  specific input types as well as <code>parse</code> methods for specific
+ *  result types. Any <code>parse</code> method that does not take a
+ *  <code>ParsePosition</code> argument should throw <code>ParseException</code>
+ *  when no text in the required format is at the beginning of the input text.
+ *
+ *  <p>
+ *  Most subclasses will also implement the following factory methods:
+ *  <ol>
+ *  <li>
+ *  <code>getInstance</code> for getting a useful format object appropriate
+ *  for the current locale
+ *  <li>
+ *  <code>getInstance(Locale)</code> for getting a useful format
+ *  object appropriate for the specified locale
+ *  </ol>
+ *  In addition, some subclasses may also implement other
+ *  <code>getXxxxInstance</code> methods for more specialized control. For
+ *  example, the <code>NumberFormat</code> class provides
+ *  <code>getPercentInstance</code> and <code>getCurrencyInstance</code>
+ *  methods for getting specialized number formatters.
+ *
+ *  <p>
+ *  Subclasses of <code>Format</code> that allow programmers to create objects
+ *  for locales (with <code>getInstance(Locale)</code> for example)
+ *  must also implement the following class method:
+ *  <blockquote>
+ *  <pre>
+ *  public static Locale[] getAvailableLocales()
+ *  </pre>
+ *  </blockquote>
+ *
+ *  <p>
+ *  And finally subclasses may define a set of constants to identify the various
+ *  fields in the formatted output. These constants are used to create a FieldPosition
+ *  object which identifies what information is contained in the field and its
+ *  position in the formatted result. These constants should be named
+ *  <code><em>item</em>_FIELD</code> where <code><em>item</em></code> identifies
+ *  the field. For examples of these constants, see <code>ERA_FIELD</code> and its
+ *  friends in {@link DateFormat}.
+ *
+ *  <h4><a name="synchronization">Synchronization</a></h4>
+ *
+ *  <p>
+ *  Formats are generally not synchronized.
+ *  It is recommended to create separate format instances for each thread.
+ *  If multiple threads access a format concurrently, it must be synchronized
+ *  externally.
+ * @see java.text.ParsePosition
+ * @see java.text.FieldPosition
+ * @see java.text.NumberFormat
+ * @see java.text.DateFormat
+ * @see java.text.MessageFormat
+ * @author Mark Davis
+ */
+export type Format = Object &
+  Serializable &
+  Cloneable & {
+    /**
+     * Formats an object to produce a string. This is equivalent to
+     *  <blockquote>
+     *  {@link #format(Object, StringBuffer, FieldPosition) format}<code>(obj,
+     *          new StringBuffer(), new FieldPosition(0)).toString();</code>
+     *  </blockquote>
+     * @param obj The object to format
+     * @return Formatted string.
+     * @throws IllegalArgumentException if the Format cannot format the given&#xA; object
+     */
+    format(obj: unknown): string;
+
+    /**
+     * Formats an object and appends the resulting text to a given string
+     *  buffer.
+     *  If the <code>pos</code> argument identifies a field used by the format,
+     *  then its indices are set to the beginning and end of the first such
+     *  field encountered.
+     * @param obj The object to format
+     * @param toAppendTo where the text is to be appended
+     * @param pos A <code>FieldPosition</code> identifying a field&#xA; in the formatted text
+     * @return the string buffer passed in as <code>toAppendTo</code>,&#xA; with formatted text appended
+     * @throws NullPointerException if <code>toAppendTo</code> or&#xA; <code>pos</code> is null
+     * @throws IllegalArgumentException if the Format cannot format the given&#xA; object
+     */
+    format(
+      obj: unknown,
+      toAppendTo: StringBuffer,
+      pos: FieldPosition
+    ): StringBuffer;
+
+    /**
+     * Formats an Object producing an <code>AttributedCharacterIterator</code>.
+     *  You can use the returned <code>AttributedCharacterIterator</code>
+     *  to build the resulting String, as well as to determine information
+     *  about the resulting String.
+     *  <p>
+     *  Each attribute key of the AttributedCharacterIterator will be of type
+     *  <code>Field</code>. It is up to each <code>Format</code> implementation
+     *  to define what the legal values are for each attribute in the
+     *  <code>AttributedCharacterIterator</code>, but typically the attribute
+     *  key is also used as the attribute value.
+     *  <p>The default implementation creates an
+     *  <code>AttributedCharacterIterator</code> with no attributes. Subclasses
+     *  that support fields should override this and create an
+     *  <code>AttributedCharacterIterator</code> with meaningful attributes.
+     * @throws NullPointerException if obj is null.
+     * @throws IllegalArgumentException when the Format cannot format the&#xA; given object.
+     * @param obj The object to format
+     * @return AttributedCharacterIterator describing the formatted value.
+     * @since 1.4
+     */
+    formatToCharacterIterator(obj: unknown): AttributedCharacterIterator;
+
+    /**
+     * Parses text from a string to produce an object.
+     *  <p>
+     *  The method attempts to parse text starting at the index given by
+     *  <code>pos</code>.
+     *  If parsing succeeds, then the index of <code>pos</code> is updated
+     *  to the index after the last character used (parsing does not necessarily
+     *  use all characters up to the end of the string), and the parsed
+     *  object is returned. The updated <code>pos</code> can be used to
+     *  indicate the starting point for the next call to this method.
+     *  If an error occurs, then the index of <code>pos</code> is not
+     *  changed, the error index of <code>pos</code> is set to the index of
+     *  the character where the error occurred, and null is returned.
+     * @param source A <code>String</code>, part of which should be parsed.
+     * @param pos A <code>ParsePosition</code> object with index and error&#xA; index information as described above.
+     * @return An <code>Object</code> parsed from the string. In case of&#xA; error, returns null.
+     * @throws NullPointerException if <code>pos</code> is null.
+     */
+    parseObject(source: String | string, pos: ParsePosition): unknown;
+
+    /**
+     * Parses text from the beginning of the given string to produce an object.
+     *  The method may not use the entire text of the given string.
+     * @param source A <code>String</code> whose beginning should be parsed.
+     * @return An <code>Object</code> parsed from the string.
+     * @throws ParseException if the beginning of the specified string&#xA; cannot be parsed.
+     */
+    parseObject(source: String | string): unknown;
+
+    /**
+     * Creates and returns a copy of this object.
+     * @return a clone of this instance.
+     */
+    clone(): unknown;
+  };

package/types/java/text/Format/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  format: function format() {},
+  formatToCharacterIterator: function formatToCharacterIterator() {},
+  parseObject: function parseObject() {},
+  clone: function clone() {}
+};
+exports["default"] = _default;

package/types/java/text/Format.Field/index.d.ts

@@ -0,0 +1,10 @@
+import type { Attribute } from "../AttributedCharacterIterator.Attribute";
+
+/**
+ * Defines constants that are used as attribute keys in the
+ *  <code>AttributedCharacterIterator</code> returned
+ *  from <code>Format.formatToCharacterIterator</code> and as
+ *  field identifiers in <code>FieldPosition</code>.
+ * @since 1.4
+ */
+export type Field = Attribute & {};

package/types/java/text/Format.Field/index.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {};
+exports["default"] = _default;