@nxtedition/types 23.1.3 → 23.1.5

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.
 
@@ -58,6 +60,7 @@ declare interface AssetCreatedProvidedRecord {
 
 declare interface AssetDaemonRecord {
     "user-notify"?: boolean;
+    validate?: boolean;
 }
 
 declare interface AssetDaemonUserNotifyStateRecord {
@@ -65,6 +68,11 @@ declare interface AssetDaemonUserNotifyStateRecord {
     version?: number;
 }
 
+declare interface AssetDaemonValidateStateRecord {
+    since?: string | 0 | null;
+    version?: number;
+}
+
 declare interface AssetDeadlinesRecord {
     value?: Nxtpression<string, {
         id: string;
@@ -687,7 +695,7 @@ declare interface DeviceDomainStatusRecord {
     version?: string;
 }
 
-declare interface DomainRecords extends AssetDomainRecords, AuthDomainRecords, BundleDomainRecords, CalendarEventDomainRecords, CloneDomainRecords, CommentReactionDomainRecords, CommentReadMarkDomainRecords, CommentDomainRecords, ConditionDomainRecords, ConnectionDomainRecords, ContactDomainRecords, DeepstreamDomainRecords, DesignDomainRecords, DeviceDomainRecords, EditDomainRecords, EventDomainRecords, FileDomainRecords, FolderDomainRecords, GeneralDomainRecords, HarvestDomainRecords, IngestclipDomainRecords, IngestScheduleDomainRecords, MediaDomainRecords, MonitorDomainRecords, NoteDomainRecords, PanelDomainRecords, PermissionDomainRecords, PipelinePresetDomainRecords, PipelineDomainRecords, PlanningDomainRecords, PrompterDomainRecords, PublishDomainRecords, PublishedDomainRecords, RenderPresetDomainRecords, RenderDomainRecords, RevsDomainRecords, RoleDomainRecords, SchemaDomainRecords, ScriptDomainRecords, SearchDomainRecords, SettingsDomainRecords, ShotboxDomainRecords, StoryboardDomainRecords, StreamDomainRecords, SubtitleStyleDomainRecords, SubtitleDomainRecords, TemplateDomainRecords, UserNotificationStatusDomainRecords, UserNotificationDomainRecords, UserDomainRecords, UsernameDomainRecords {
+declare interface DomainRecords extends AssetDomainRecords, AuthDomainRecords, BundleDomainRecords, CalendarEventDomainRecords, CloneDomainRecords, CommentReactionDomainRecords, CommentReadMarkDomainRecords, CommentDomainRecords, ConditionDomainRecords, ConnectionDomainRecords, ContactDomainRecords, DeepstreamDomainRecords, DesignDomainRecords, DeviceDomainRecords, EditDomainRecords, EventDomainRecords, FileDomainRecords, FolderDomainRecords, GalleryDomainRecords, GeneralDomainRecords, HarvestDomainRecords, IngestclipDomainRecords, IngestScheduleDomainRecords, MediaDomainRecords, MonitorDomainRecords, NoteDomainRecords, PanelDomainRecords, PermissionDomainRecords, PipelinePresetDomainRecords, PipelineDomainRecords, PlanningDomainRecords, PrompterDomainRecords, PublishDomainRecords, PublishedDomainRecords, RenderPresetDomainRecords, RenderDomainRecords, RevsDomainRecords, RoleDomainRecords, SchemaDomainRecords, ScriptDomainRecords, SearchDomainRecords, SettingsDomainRecords, ShotboxDomainRecords, StorageDomainRecords, StoryboardDomainRecords, StreamDomainRecords, SubtitleStyleDomainRecords, SubtitleDomainRecords, TemplateDomainRecords, UserNotificationStatusDomainRecords, UserNotificationDomainRecords, UserDomainRecords, UsernameDomainRecords {
 }
 
 declare type Dynamic = false | string[];
@@ -761,8 +769,11 @@ declare type EmptyObject = {
 
  // With `EmptyObject` only the first case is valid.
  const bar1: EmptyObject = {}; // Pass
- const bar2: EmptyObject = 42; // Fail
- const bar3: EmptyObject = []; // Fail
+ // @ts-expect-error
+ const bar2: EmptyObject = []; // Fail
+ // @ts-expect-error
+ const bar3: EmptyObject = 42; // Fail
+ // @ts-expect-error
  const bar4: EmptyObject = {a: 1}; // Fail
  ```
 
@@ -807,6 +818,9 @@ declare interface EventDomainRecords {
     ":event.duration?": EventDurationRecord;
     ":event.children?": EventChildrenRecord;
     ":event.props?": EventPropsRecord;
+    ":event.stats?": EventStatsRecord;
+    ":event.readDuration?": EventReadDurationRecord;
+    ":event.readRate?": EventReadRateRecord;
 }
 
 declare interface EventDurationRecord {
@@ -832,6 +846,7 @@ declare interface EventOverlayRecord {
 declare type EventProps = {
     source?: string;
     cueCard?: boolean | string;
+    printRundownColor?: string;
     startTime?: number;
     shotboxGroup?: string | string[];
     shotboxVisible?: boolean;
@@ -839,16 +854,34 @@ 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;
     duration?: number | null;
+    position?: string;
     text?: string;
     lang?: string;
     style?: string;
     styleOverrides?: SubtitleEventStyleOverrides;
 }
 
+declare interface EventStatsRecord {
+    type?: string;
+}
+
 declare interface EventTemplateRecord {
     mixin?: string[];
     properties?: object;
@@ -1010,9 +1043,11 @@ declare interface FileConnectionSmbRecord extends FileConnectionBase {
     protocol?: "smb";
     host?: string;
     share?: string;
+    root?: string;
     workgroup?: string;
     username?: string;
     password?: string;
+    createFolders?: boolean;
 }
 
 declare interface FileDomainRecords {
@@ -1184,6 +1219,16 @@ declare interface FormattedTextNodeContent {
     format?: number;
 }
 
+declare interface GalleryDomainRecord {
+    sources?: {
+        program?: string;
+    };
+}
+
+declare interface GalleryDomainRecords {
+    ":gallery": GalleryDomainRecord;
+}
+
 declare interface GeneralAssetRecord {
     title?: string;
     tags?: string;
@@ -1358,7 +1403,7 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
 
  @example
  ```
- import {If} from 'type-fest';
+ import type {If} from 'type-fest';
 
  type A = If<true, 'yes', 'no'>;
  //=> 'yes'
@@ -1378,7 +1423,7 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
 
  @example
  ```
- import {If, IsAny, IsNever} from 'type-fest';
+ import type {If, IsAny, IsNever} from 'type-fest';
 
  type A = If<IsAny<unknown>, 'is any', 'not any'>;
  //=> 'not any'
@@ -1389,7 +1434,7 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
 
  @example
  ```
- import {If, IsEqual} from 'type-fest';
+ import type {If, IsEqual} from 'type-fest';
 
  type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
@@ -1400,6 +1445,41 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
  //=> 'not equal'
  ```
 
+ Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+ @example
+ ```
+ import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+ type HundredZeroes = StringRepeat<'0', 100>;
+
+ // The following implementation is not tail recursive
+ type Includes<S extends string, Char extends string> =
+ 	S extends `${infer First}${infer Rest}`
+ 		? If<IsEqual<First, Char>,
+ 			'found',
+ 			Includes<Rest, Char>>
+ 		: 'not found';
+
+ // Hence, instantiations with long strings will fail
+ // @ts-expect-error
+ type Fails = Includes<HundredZeroes, '1'>;
+ //           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ // Error: Type instantiation is excessively deep and possibly infinite.
+
+ // However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+ type IncludesWithoutIf<S extends string, Char extends string> =
+ 	S extends `${infer First}${infer Rest}`
+ 		? IsEqual<First, Char> extends true
+ 			? 'found'
+ 			: IncludesWithoutIf<Rest, Char>
+ 		: 'not found';
+
+ // Now, instantiations with long strings will work
+ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+ //=> 'not found'
+ ```
+
  @category Type Guard
  @category Utilities
  */
@@ -1483,7 +1563,7 @@ declare type InternalIsUnion<T, U = T> =
 	IsNever<T> extends true
 		? false
 		: T extends any
-			? [U] extends [T]
+			? IsEqual<U, T> extends true
 				? false
 				: true
 			: never
@@ -1503,15 +1583,54 @@ declare type InternalIsUnion<T, U = T> =
  import type {IsEmptyObject} from 'type-fest';
 
  type Pass = IsEmptyObject<{}>; //=> true
- type Fail = IsEmptyObject<[]>; //=> false
- type Fail = IsEmptyObject<null>; //=> false
+ type Fail1 = IsEmptyObject<[]>; //=> false
+ type Fail2 = IsEmptyObject<null>; //=> false
  ```
 
- @see EmptyObject
+ @see {@link EmptyObject}
  @category Object
  */
 declare type IsEmptyObject<T> = T extends EmptyObject_2 ? true : false;
 
+/**
+ Returns a boolean for whether the two given types are equal.
+
+ @link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+ @link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+ Use-cases:
+ - If you want to make a conditional branch based on the result of a comparison of two types.
+
+ @example
+ ```
+ import type {IsEqual} from 'type-fest';
+
+ // This type returns a boolean for whether the given array includes the given item.
+ // `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+ type Includes<Value extends readonly any[], Item> =
+ 	Value extends readonly [Value[0], ...infer rest]
+ 		? IsEqual<Value[0], Item> extends true
+ 			? true
+ 			: Includes<rest, Item>
+ 		: false;
+ ```
+
+ @category Type Guard
+ @category Utilities
+ */
+declare type IsEqual<A, B> =
+	[A] extends [B]
+		? [B] extends [A]
+			? _IsEqual<A, B>
+			: false
+		: false;
+
+declare type _IsEqual<A, B> =
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
+		? true
+		: false;
+
 /**
  Returns a boolean for whether the given type is `never`.
 
@@ -1525,29 +1644,41 @@ declare type IsEmptyObject<T> = T extends EmptyObject_2 ? true : false;
  ```
  import type {IsNever, And} from 'type-fest';
 
- // https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
- type AreStringsEqual<A extends string, B extends string> =
- 	And<
- 		IsNever<Exclude<A, B>> extends true ? true : false,
- 		IsNever<Exclude<B, A>> extends true ? true : false
- 	>;
-
- type EndIfEqual<I extends string, O extends string> =
- 	AreStringsEqual<I, O> extends true
- 		? never
- 		: void;
-
- function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
- 	if (input === output) {
- 		process.exit(0);
- 	}
- }
-
- endIfEqual('abc', 'abc');
+ type A = IsNever<never>;
+ //=> true
+
+ type B = IsNever<any>;
+ //=> false
+
+ type C = IsNever<unknown>;
+ //=> false
+
+ type D = IsNever<never[]>;
+ //=> false
+
+ type E = IsNever<object>;
+ //=> false
+
+ type F = IsNever<string>;
+ //=> false
+ ```
+
+ @example
+ ```
+ import type {IsNever} from 'type-fest';
+
+ type IsTrue<T> = T extends true ? true : false;
+
+ // When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+ type A = IsTrue<never>;
  //=> never
 
- endIfEqual('abc', '123');
- //=> void
+ // If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+ type IsTrueFixed<T> =
+ 	IsNever<T> extends true ? false : T extends true ? true : false;
+
+ type B = IsTrueFixed<never>;
+ //=> false
  ```
 
  @category Type Guard
@@ -1607,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";
@@ -1786,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";
@@ -1821,6 +1962,7 @@ declare type Minimum<Value extends number | bigint> = TagBase<{
 declare interface MiscRecords {
     "asset-daemon": AssetDaemonRecord;
     "asset-daemon:user-notify.state": AssetDaemonUserNotifyStateRecord;
+    "asset-daemon:validate.state": AssetDaemonValidateStateRecord;
     "deepstream-replicator.stats?": DeepstreamReplicatorStatsRecord;
 }
 
@@ -2000,7 +2142,7 @@ declare interface NxtError {
     errors?: NxtError[] | null;
 }
 
-declare type Nxtpression<ReturnValue = unknown, Context extends object = object> = {
+declare type Nxtpression<ReturnValue = unknown, Context extends Record<string, unknown> = Record<string, unknown>> = {
     /**
      * TS-HACK: this property doesn't really exist on the nxtpression string,
      * it is only here to make sure the generic Context won't get stripped.
@@ -2060,6 +2202,7 @@ declare interface NxtStatusMessage {
         title: string;
         url: string;
     };
+    data?: unknown;
 }
 
 declare interface NxtStatusNode extends NxtStatusObject {
@@ -2107,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> {
     /**
@@ -2120,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.
@@ -2129,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
@@ -2192,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>;
     /**
@@ -2278,6 +2414,10 @@ declare interface Operator<T, R> {
 declare interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
 }
 
+declare type PageOrientation = "landscape" | "portrait";
+
+declare type PageSize = "A5" | "A4" | "A3";
+
 declare interface PanelDomainPanelRecord {
     title?: string;
     /**
@@ -2311,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";
@@ -2399,6 +2550,39 @@ declare interface PlanningRecord {
     deadline?: string | null;
 }
 
+declare type PrintOptionalScriptNodes = "event" | "event-data" | "comment" | "heading" | "list" | "quote" | "paragraph" | "horizontalrule";
+
+declare type PrintOptions = PrintScriptOptions | PrintRundownOptions;
+
+declare interface PrintOptionsBase {
+    title: string;
+    horizontalMargin: number;
+    pageSize: PageSize;
+    orientation: PageOrientation;
+    fontSize: number;
+    fontFamily?: string;
+    hide: PrintOptionalScriptNodes[];
+}
+
+declare interface PrintRundownColumn {
+    key: "id" | "title" | "time" | "duration" | "position" | "accDuration" | "type";
+    label: string;
+    width: string;
+    textAlign: "right" | "left" | "center";
+}
+
+declare interface PrintRundownOptions extends PrintOptionsBase {
+    type: "rundown";
+    columns: PrintRundownColumn[];
+    rangeStart?: number;
+    rangeEnd?: number;
+    hide: Exclude<PrintOptionalScriptNodes, "event-data">[];
+}
+
+declare interface PrintScriptOptions extends PrintOptionsBase {
+    type: "script";
+}
+
 declare interface PromotedTag {
     name: string | null;
     icon: string | null;
@@ -2527,6 +2711,8 @@ number,
 number
 ];
 
+declare type ReadType = "characters" | "words" | "wordsPerMinute";
+
 declare interface Records extends KeyedDomainRecords, KeyedProvidedDomainRecords, DbExactRecords, DbProvidedRecord {
     [key: string]: unknown;
 }
@@ -2834,6 +3020,7 @@ declare interface RenderSceneObject {
     transcribe?: {
         language?: string;
         pan?: number[];
+        diarization?: boolean;
     };
     /** @deprecated Use video.crop instead */
     crop?: RenderSceneCrop;
@@ -2898,13 +3085,23 @@ declare interface RevsRecord {
 }
 
 declare interface RoleDomainRecords {
+    ":role": RoleRecord;
+    ":role.users?": RoleUsersRecord;
     ":role.tags": RoleTagsRecord;
 }
 
+declare type RoleRecord = {
+    permissions?: Record<string, string[]>;
+};
+
 declare interface RoleTagsRecord {
     value: string[];
 }
 
+declare type RoleUsersRecord = {
+    value?: string[];
+};
+
 declare interface RpcPermission {
     type: "rpc";
     method: string;
@@ -3103,6 +3300,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>;
 };
 
@@ -3251,6 +3452,7 @@ declare interface Settings {
             sortBy?: "index" | "title";
             showPreview?: boolean;
         };
+        contentMaxWidth?: number;
         colorTags?: PromotedTag[];
         readType?: "characters" | "words" | "wordsPerMinute";
         readRate?: number;
@@ -3436,6 +3638,7 @@ declare interface Settings {
     };
     print?: {
         fontFamilies?: string[];
+        presets?: Array<PrintOptions>;
     };
     hiddenPreviews?: Array<{
         id?: string;
@@ -3451,6 +3654,7 @@ declare interface Settings {
             downloadPath?: string;
             renderPath?: string;
             renderPresetPath?: string;
+            renderPresets?: string[];
             videoRenderPreset?: string;
             imageRenderPreset?: string;
             audioRenderPreset?: string;
@@ -3461,6 +3665,9 @@ declare interface Settings {
                 template?: string;
             };
         };
+        ograf?: {
+            template?: string;
+        };
         rive?: {
             template?: string;
         };
@@ -3536,8 +3743,10 @@ declare interface Settings {
         layout?: string;
     };
     performance?: {
-        /** List of message identifiers to ignore in overall health aggregation (format: "serviceName:messageText") */
-        ignoredMessages?: string[];
+        /** List of message identifiers to ignore warnings (format: "serviceName:messageText") */
+        ignoredWarnings?: string[];
+        /** List of message identifiers to ignore errors (format: "serviceName:messageText") */
+        ignoredErrors?: string[];
     };
     app?: {
         enableUpdate?: boolean;
@@ -3622,16 +3831,12 @@ declare interface ShotboxStreamGroup {
  ```
  import type {SingleKeyObject} from 'type-fest';
 
- const someFunction = <T>(parameter: SingleKeyObject<T>) => {};
+ declare function someFunction<T>(parameter: SingleKeyObject<T>): void;
 
- someFunction({
- 	value: true
- });
+ someFunction({value: true});
 
- someFunction({
- 	value: true,
- 	otherKey: true
- });
+ // @ts-expect-error
+ someFunction({value: true, otherKey: true});
  // Error: Argument of type '{value: boolean; otherKey: boolean}' is not assignable to parameter of type 'never'.ts(2345)
  ```
 
@@ -3646,6 +3851,48 @@ declare type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
 
 declare type StatsRecord = Union["stats"];
 
+declare interface StorageDomainRecord {
+    zone: string;
+    hostname: string | null;
+    port?: number | null;
+    location?: string;
+    cache?: boolean | null;
+    allows?: string[];
+    capacity?: number | null;
+    rxBytesSecMax?: number | null;
+    txBytesSecMax?: number | null;
+    rxBytesSecLimit?: number | null;
+    txBytesSecLimit?: number | null;
+}
+
+declare interface StorageDomainRecords {
+    ":storage": StorageDomainRecord;
+    ":storage.stats": StorageStatsDomainRecord;
+    ":storage-zone": StorageZoneDomainRecord;
+}
+
+declare interface StorageFsStats {
+    concurrency?: number;
+    path?: string;
+    snapshot?: number | null;
+    available?: number;
+    free?: number;
+    used?: number;
+    size?: number;
+    state?: string;
+    [key: string]: unknown;
+}
+
+declare interface StorageIoQueues {
+    highest: number;
+    higher: number;
+    high: number;
+    normal: number;
+    low: number;
+    lower: number;
+    lowest: number;
+}
+
 declare interface StorageLocationsRecord {
     [key: string]: StorageLocationsRecordEntry;
 }
@@ -3675,6 +3922,58 @@ declare interface StorageRecords {
     "storage.zones?": StorageZonesRecord;
 }
 
+declare interface StorageS3Stats {
+    bucket?: string;
+    region?: string;
+    endpoint?: string;
+    path?: string;
+    storageClass?: string;
+    [key: string]: unknown;
+}
+
+declare interface StorageStatsDomainRecord {
+    id: string;
+    location: string;
+    timestamp: string;
+    type: string;
+    zone: string;
+    origin: string;
+    free: number | null;
+    size: number | null;
+    available: number | null;
+    cache: boolean | null;
+    capacity: number | null;
+    limiter: {
+        readBytesPerSecond: number | undefined;
+        writeBytesPerSecond: number | undefined;
+    };
+    http: {
+        downstreamConnected: number;
+        upstreamConnected: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    };
+    io: {
+        read: {
+            bytesPerSecond: number;
+            pending: number;
+            queues: StorageIoQueues;
+        };
+        write: {
+            bytesPerSecond: number;
+            pending: number;
+            queues: StorageIoQueues;
+        };
+    };
+    fs?: StorageFsStats;
+    s3?: StorageS3Stats;
+}
+
+declare interface StorageZoneDomainRecord {
+    priority?: number;
+}
+
 declare interface StorageZonesRecord {
     [key: string]: {
         priority: number;
@@ -3802,8 +4101,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> {
     /**
@@ -3816,7 +4113,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.
@@ -3835,23 +4131,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;
@@ -3869,12 +4162,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.
@@ -3895,7 +4185,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;
     /**
@@ -4063,88 +4352,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;
@@ -4159,6 +4366,39 @@ declare interface TemplateDomainRecords {
 
 declare interface TemplateProperty {
     path?: string;
+    type?: string;
+    label?: string;
+    defaultValue?: string;
+    widget?: {
+        type: string;
+    };
+    properties?: object;
+    items?: {
+        properties?: Record<string, TemplatePropertySchema>;
+    };
+    render?: {
+        type: "image";
+        profile?: {
+            format?: string;
+            video?: {
+                width: number;
+                height: number;
+                fit: "cover";
+            };
+        };
+    };
+}
+
+declare interface TemplatePropertySchema {
+    path?: string;
+    type?: string;
+    label?: string;
+    defaultValue?: string;
+    widget?: {
+        type: string;
+    };
+    items?: TemplatePropertySchema;
+    properties?: Record<string, TemplatePropertySchema>;
 }
 
 declare interface TemplateRecord {
@@ -4210,31 +4450,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";