@nxtedition/types 23.1.4 → 23.1.6

package/dist/nxtpression.d.ts

@@ -1,5 +1,7 @@
 /// <reference lib="esnext.asynciterable" />
 
+import { TagBase } from './TagBase';
+
 /**
  All diff* functions should return a list of operations, often empty.
 
@@ -817,6 +819,8 @@ declare interface EventDomainRecords {
     ":event.children?": EventChildrenRecord;
     ":event.props?": EventPropsRecord;
     ":event.stats?": EventStatsRecord;
+    ":event.readDuration?": EventReadDurationRecord;
+    ":event.readRate?": EventReadRateRecord;
 }
 
 declare interface EventDurationRecord {
@@ -850,6 +854,19 @@ declare type EventProps = {
 
 declare type EventPropsRecord = EventProps & Record<Exclude<string, keyof EventProps>, JsonValue>;
 
+declare interface EventReadDurationRecord {
+    numChars?: number;
+    numWords?: number;
+    readRate?: number;
+    readDuration?: number;
+    readType?: ReadType;
+}
+
+declare interface EventReadRateRecord {
+    readRate?: number;
+    readType?: ReadType;
+}
+
 declare interface EventRecord {
     start?: number | null;
     end?: number | null;
@@ -1721,24 +1738,29 @@ declare interface ListNodeContent {
 }
 
 /**
- * Maximum value constraint tag.
- *
- * Enforces that a numeric value must be less than or equal to the specified
- * maximum. This constraint validates that the input value satisfies: input <=
- * maximum.
+ * Inclusive maximum value constraint (value <= max).
  *
- * Example usage:
+ * `Maximum<N>` is a type tag that validates numeric values are less than or
+ * equal to the specified bound. Apply it to `number` or `bigint` properties
+ * using TypeScript intersection types.
  *
- * ```typescript
- * type Percentage = number & tags.Maximum<100>; // Must be <= 100
- * type SmallInt = bigint & tags.Maximum<255n>; // BigInt must be <= 255
- * ```
+ * This constraint is **mutually exclusive** with {@link ExclusiveMaximum} - you
+ * cannot use both on the same property. Use `Maximum` for inclusive bounds (<=)
+ * and `ExclusiveMaximum` for exclusive bounds (<).
  *
- * Note: This tag is mutually exclusive with ExclusiveMaximum. You cannot apply
- * both Maximum and ExclusiveMaximum constraints to the same property.
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It also generates `maximum` in JSON Schema output.
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @template Value - The maximum value constraint (number or bigint literal)
+ * @example
+ *   interface Rating {
+ *     // Score from 0-100
+ *     score: number & Minimum<0> & Maximum<100>;
+ *     // Percentage cannot exceed 1.0
+ *     ratio: number & Maximum<1.0>;
+ *   }
+ *
+ * @template Value The maximum allowed value (inclusive)
  */
 declare type Maximum<Value extends number | bigint> = TagBase<{
     target: Value extends bigint ? "bigint" : "number";
@@ -1900,24 +1922,29 @@ declare interface Message {
 declare type MethodsRecord = Union["methods"];
 
 /**
- * Minimum value constraint tag.
- *
- * Enforces that a numeric value must be greater than or equal to the specified
- * minimum. This constraint validates that the input value satisfies: input >=
- * minimum.
+ * Inclusive minimum value constraint (value >= min).
  *
- * Example usage:
+ * `Minimum<N>` is a type tag that validates numeric values are greater than or
+ * equal to the specified bound. Apply it to `number` or `bigint` properties
+ * using TypeScript intersection types.
  *
- * ```typescript
- * type Age = number & tags.Minimum<0>; // Age must be 0 or greater
- * type Balance = bigint & tags.Minimum<0n>; // BigInt balance must be non-negative
- * ```
+ * This constraint is **mutually exclusive** with {@link ExclusiveMinimum} - you
+ * cannot use both on the same property. Use `Minimum` for inclusive bounds (>=)
+ * and `ExclusiveMinimum` for exclusive bounds (>).
  *
- * Note: This tag is mutually exclusive with ExclusiveMinimum. You cannot apply
- * both Minimum and ExclusiveMinimum constraints to the same property.
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It also generates `minimum` in JSON Schema output.
  *
  * @author Jeongho Nam - https://github.com/samchon
- * @template Value - The minimum value constraint (number or bigint literal)
+ * @example
+ *   interface Product {
+ *     // Price must be 0 or greater
+ *     price: number & Minimum<0>;
+ *     // Quantity must be at least 1
+ *     quantity: number & Minimum<1>;
+ *   }
+ *
+ * @template Value The minimum allowed value (inclusive)
  */
 declare type Minimum<Value extends number | bigint> = TagBase<{
     target: Value extends bigint ? "bigint" : "number";
@@ -2223,8 +2250,6 @@ declare interface NxtStatusService extends NxtStatusObject {
 /**
  * A representation of any set of values over any amount of time. This is the most basic building block
  * of RxJS.
- *
- * @class Observable<T>
  */
 declare class Observable<T> implements Subscribable<T> {
     /**
@@ -2236,8 +2261,7 @@ declare class Observable<T> implements Subscribable<T> {
      */
     operator: Operator<any, T> | undefined;
     /**
-     * @constructor
-     * @param {Function} subscribe the function that is called when the Observable is
+     * @param subscribe The function that is called when the Observable is
      * initially subscribed to. This function is given a Subscriber, to which new values
      * can be `next`ed, or an `error` method can be called to raise an error, or
      * `complete` can be called to notify of a successful completion.
@@ -2245,20 +2269,16 @@ declare class Observable<T> implements Subscribable<T> {
     constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
     /**
      * Creates a new Observable by calling the Observable constructor
-     * @owner Observable
-     * @method create
-     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
-     * @return {Observable} a new observable
-     * @nocollapse
+     * @param subscribe the subscriber function to be passed to the Observable constructor
+     * @return A new observable.
      * @deprecated Use `new Observable()` instead. Will be removed in v8.
      */
     static create: (...args: any[]) => any;
     /**
      * Creates a new Observable, with this Observable instance as the source, and the passed
      * operator defined as the new observable's operator.
-     * @method lift
      * @param operator the operator defining the operation to take on the observable
-     * @return a new observable with the Operator applied
+     * @return A new observable with the Operator applied.
      * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
      * If you have implemented an operator using `lift`, it is recommended that you create an
      * operator by simply returning `new Observable()` directly. See "Creating new operators from
@@ -2308,9 +2328,9 @@ declare class Observable<T> implements Subscribable<T> {
      * // 'Total: 6'
      * ```
      *
-     * @param next a handler for each value emitted by the observable
-     * @return a promise that either resolves on observable completion or
-     *  rejects with the handled error
+     * @param next A handler for each value emitted by the observable.
+     * @return A promise that either resolves on observable completion or
+     * rejects with the handled error.
      */
     forEach(next: (value: T) => void): Promise<void>;
     /**
@@ -2431,22 +2451,33 @@ declare interface ParagraphNodeContent extends ElementNodeContent {
 declare type Paths<Data> = keyof Data & string;
 
 /**
- * String pattern (regular expression) constraint tag.
+ * Regular expression pattern constraint for strings.
  *
- * Validates that a string matches a specified regular expression pattern. Use
- * this tag to enforce custom string formats through regex validation.
+ * `Pattern<Regex>` is a type tag that validates string values match the
+ * specified regular expression pattern. Apply it to `string` properties using
+ * TypeScript intersection types.
  *
- * Examples:
+ * This constraint is **mutually exclusive** with {@link Format} - you cannot use
+ * both on the same property. Use `Pattern` for custom regex validation, or
+ * `Format` for standard formats (email, uuid, etc.).
  *
- * ```ts
- * type PhoneNumber = string & Pattern<"^\d{3}-\d{3}-\d{4}$">; // 123-456-7890
- * type HexColor = string & Pattern<"^#[0-9A-Fa-f]{6}$">; // #FF5733
- * ```
+ * The pattern should be a valid JavaScript regular expression string without
+ * the surrounding slashes. The entire string must match (implicit `^` and `$`
+ * anchors).
  *
- * Note: This tag is mutually exclusive with the Format tag. You cannot use both
- * Pattern and Format on the same type.
+ * The constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates `pattern` in JSON Schema output.
  *
  * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   interface Product {
+ *     // SKU format: 3 letters, dash, 4 digits
+ *     sku: string & Pattern<"^[A-Z]{3}-[0-9]{4}$">;
+ *     // Phone number: digits and optional dashes
+ *     phone: string & Pattern<"^[0-9-]+$">;
+ *   }
+ *
+ * @template Value Regular expression pattern as a string literal
  */
 declare type Pattern<Value extends string> = TagBase<{
     target: "string";
@@ -2680,6 +2711,8 @@ number,
 number
 ];
 
+declare type ReadType = "characters" | "words" | "wordsPerMinute";
+
 declare interface Records extends KeyedDomainRecords, KeyedProvidedDomainRecords, DbExactRecords, DbProvidedRecord {
     [key: string]: unknown;
 }
@@ -2949,6 +2982,11 @@ declare interface RenderSceneFilters {
     };
 }
 
+declare interface RenderSceneFocus {
+    x?: number;
+    y?: number;
+}
+
 declare type RenderSceneInterlaced = false | "tff" | "bff";
 
 declare interface RenderSceneObject {
@@ -2973,6 +3011,7 @@ declare interface RenderSceneObject {
     video?: {
         filters?: RenderSceneFilters;
         crop?: RenderSceneCrop;
+        focus?: RenderSceneFocus;
         orientation?: number;
         /** @deprecated Use input.video.interlaced */
         interlaced?: RenderSceneInterlaced | null;
@@ -3267,6 +3306,10 @@ declare type SerializedLexicalNode = {
     type: string;
     /** A numeric version for this schema, defaulting to 1, but not generally recommended for use */
     version: number;
+    /**
+     * Any state persisted with the NodeState API that is not
+     * configured for flat storage
+     */
     [NODE_STATE_KEY]?: Record<string, unknown>;
 };
 
@@ -4064,8 +4107,6 @@ declare interface Subscribable<T> {
  * a Subscriber, in order to provide Subscription-like capabilities such as
  * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
  * implementing operators, but it is rarely used as a public API.
- *
- * @class Subscriber<T>
  */
 declare class Subscriber<T> extends Subscription implements Observer<T> {
     /**
@@ -4078,7 +4119,6 @@ declare class Subscriber<T> extends Subscription implements Observer<T> {
      * Observer.
      * @return A Subscriber wrapping the (partially defined)
      * Observer represented by the given arguments.
-     * @nocollapse
      * @deprecated Do not use. Will be removed in v8. There is no replacement for this
      * method, and there is no reason to be creating instances of `Subscriber` directly.
      * If you have a specific use case, please file an issue.
@@ -4097,23 +4137,20 @@ declare class Subscriber<T> extends Subscription implements Observer<T> {
      * The {@link Observer} callback to receive notifications of type `next` from
      * the Observable, with a value. The Observable may call this method 0 or more
      * times.
-     * @param {T} [value] The `next` value.
-     * @return {void}
+     * @param value The `next` value.
      */
-    next(value?: T): void;
+    next(value: T): void;
     /**
      * The {@link Observer} callback to receive notifications of type `error` from
      * the Observable, with an attached `Error`. Notifies the Observer that
      * the Observable has experienced an error condition.
-     * @param {any} [err] The `error` exception.
-     * @return {void}
+     * @param err The `error` exception.
      */
     error(err?: any): void;
     /**
      * The {@link Observer} callback to receive a valueless notification of type
      * `complete` from the Observable. Notifies the Observer that the Observable
      * has finished sending push-based notifications.
-     * @return {void}
      */
     complete(): void;
     unsubscribe(): void;
@@ -4131,12 +4168,9 @@ declare class Subscriber<T> extends Subscription implements Observer<T> {
  * method, which will attach a child Subscription to the current Subscription.
  * When a Subscription is unsubscribed, all its children (and its grandchildren)
  * will be unsubscribed as well.
- *
- * @class Subscription
  */
 declare class Subscription implements SubscriptionLike {
     private initialTeardown?;
-    /** @nocollapse */
     static EMPTY: Subscription;
     /**
      * A flag to indicate whether this Subscription has already been unsubscribed.
@@ -4157,7 +4191,6 @@ declare class Subscription implements SubscriptionLike {
      * Disposes the resources held by the subscription. May, for instance, cancel
      * an ongoing Observable execution or cancel any other type of work that
      * started when the Subscription was created.
-     * @return {void}
      */
     unsubscribe(): void;
     /**
@@ -4325,88 +4358,6 @@ declare interface SubtitleStyleDomainRecords {
     ":subtitle-style": SubtitleStyleDomainRecord;
 }
 
-/**
- * Base type for all validation tags in typia.
- *
- * TagBase provides the foundation for all typia's validation tags. It attaches
- * metadata to TypeScript types that typia's transformer processes at
- * compile-time to generate optimized runtime validation code.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @example
- *   ```typescript
- *   // Custom tag example
- *   type MyCustomTag<Value extends number> = TagBase<{
- *   target: "number";
- *   kind: "MyCustom";
- *   value: Value;
- *   validate: `$input === ${Value}`;
- *   }>;
- *   ```
- *
- * @template Props - Tag properties that define validation behavior
- */
-declare type TagBase<Props extends TagBase.IProps<any, any, any, any, any, any>> = {
-    /**
-     * This is a dummy property for compilation.
-     *
-     * It does not mean anything in runtime.
-     */
-    "typia.tag"?: Props;
-};
-
-declare namespace TagBase {
-    /**
-     * Properties interface for validation tags.
-     *
-     * @author Jeongho Nam - https://github.com/samchon
-     */
-    interface IProps<Target extends "boolean" | "bigint" | "number" | "string" | "array" | "object", Kind extends string, Value extends boolean | bigint | number | string | undefined, Validate extends string | {
-        [key in Target]?: string;
-    }, Exclusive extends boolean | string[], Schema extends object | undefined> {
-        /**
-         * Target type.
-         *
-         * If user tries to adapt this tag to a different type, it would be a
-         * compile error.
-         *
-         * For example, you've configured target type as `string`, but user adapted
-         * it onto a `number` type (`number & YourCustomTag<Value>`), then it would
-         * be blocked by TypeScript compiler.
-         */
-        target: Target;
-        /** What kind of tag is this? */
-        kind: Kind;
-        /** Value to be configured by user. */
-        value: Value;
-        /**
-         * Validation script.
-         *
-         * This script would be inserted into the generated validation function. In
-         * here script, target variable name must be `$input`. The variable name
-         * `$input` would be transformed to the suitable when compilation.
-         *
-         * Also, If you've take a mistake on this script, compile error would be
-         * occurred. So, define it with confidence. Compiler will block all your
-         * mistakes.
-         */
-        validate?: Validate;
-        /**
-         * Exclusive option.
-         *
-         * If this property configured as `true`, same {@link kind} tag cannot be
-         * duplicated in the target type. Otherwise, if you've configured this
-         * property as string array, all of the {@link kind} value assigned tags
-         * cannot be compatible in the target type.
-         *
-         * @default false
-         */
-        exclusive?: Exclusive | string[];
-        /** Additional schema info assigned to the {@link IJsonSchema} object. */
-        schema?: Schema;
-    }
-}
-
 declare interface TagPermission {
     type: "tag";
     method?: undefined;
@@ -4505,31 +4456,37 @@ declare interface TranscribeReplaceReplacer {
 }
 
 /**
- * Type tag for specifying numeric bit-width representations.
+ * Numeric precision and bit-width type constraint.
+ *
+ * `Type<Value>` is a type tag that constrains numeric values to specific
+ * bit-width representations. This is essential for Protocol Buffers
+ * serialization and ensures values fit within their specified ranges.
  *
- * Constrains numeric types to specific bit-width formats used in systems
- * programming and protocol buffers. Ensures numbers conform to
- * platform-specific representations.
+ * Available types:
  *
- * Supported types:
+ * - `"int32"`: Signed 32-bit integer (-2,147,483,648 to 2,147,483,647)
+ * - `"uint32"`: Unsigned 32-bit integer (0 to 4,294,967,295)
+ * - `"int64"`: Signed 64-bit integer (for `number` or `bigint`)
+ * - `"uint64"`: Unsigned 64-bit integer (for `number` or `bigint`)
+ * - `"float"`: 32-bit floating point
+ * - `"double"`: 64-bit floating point (default JavaScript number)
  *
- * - `int32`: 32-bit signed integer (-2^31 to 2^31-1)
- * - `uint32`: 32-bit unsigned integer (0 to 2^32-1)
- * - `int64`: 64-bit signed integer (supports both bigint and number)
- * - `uint64`: 64-bit unsigned integer (supports both bigint and number)
- * - `float`: 32-bit floating point (single precision)
- * - `double`: 64-bit floating point (double precision, default JS number)
+ * For Protocol Buffers, integer types also determine the wire encoding. The
+ * constraint is enforced at runtime by `typia.is()`, `typia.assert()`, and
+ * `typia.validate()`. It generates appropriate `type` in JSON Schema.
  *
  * @author Jeongho Nam - https://github.com/samchon
  * @example
- *   ```typescript
- *   type Score = number & Type<"int32">;      // -2,147,483,648 to 2,147,483,647
- *   type UserId = number & Type<"uint32">;    // 0 to 4,294,967,295
- *   type FileSize = bigint & Type<"int64">;   // Large file sizes
- *   type Coordinate = number & Type<"double">; // High precision coordinates
- *   ```
+ *   interface Message {
+ *     // 32-bit unsigned integer
+ *     id: number & Type<"uint32">;
+ *     // 64-bit signed integer as bigint
+ *     timestamp: bigint & Type<"int64">;
+ *     // 32-bit float for memory efficiency
+ *     score: number & Type<"float">;
+ *   }
  *
- * @template Value - The numeric type representation
+ * @template Value Numeric type identifier
  */
 declare type Type<Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double"> = TagBase<{
     target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";

package/dist/records/domains/event.d.ts

@@ -11,6 +11,8 @@ export interface EventDomainRecords {
     ":event.children?": EventChildrenRecord;
     ":event.props?": EventPropsRecord;
     ":event.stats?": EventStatsRecord;
+    ":event.readDuration?": EventReadDurationRecord;
+    ":event.readRate?": EventReadRateRecord;
 }
 export interface EventRecord {
     start?: number | null;
@@ -56,6 +58,17 @@ export interface EventOverlayRecord {
         data: EventPropsRecord;
     };
 }
+export interface EventReadDurationRecord {
+    numChars?: number;
+    numWords?: number;
+    readRate?: number;
+    readDuration?: number;
+    readType?: ReadType;
+}
+export interface EventReadRateRecord {
+    readRate?: number;
+    readType?: ReadType;
+}
 export interface SubtitleEventStyleOverrides {
     marginL?: string;
     marginR?: string;
@@ -72,4 +85,5 @@ export interface SubtitleEventStyleOverrides {
     underline?: string;
     strikeOut?: string;
 }
+export type ReadType = "characters" | "words" | "wordsPerMinute";
 export {};