@nxtedition/types 23.0.46 → 23.0.47

package/dist/nxtpression.d.ts

@@ -1,5 +1,7 @@
 /// <reference lib="esnext.asynciterable" />
 
+import type { IsUnion } from './internal';
+
 /**
  All diff* functions should return a list of operations, often empty.
 
@@ -393,6 +395,18 @@ declare interface CopyOperation {
     path: string;
 }
 
+declare type DbDomainKeys = Exclude<keyof DomainRecords, ProvidedDomainKeys>;
+
+declare type DbExactKeys = Exclude<keyof ExactRecords, ProvidedExactKeys>;
+
+declare type DbExactRecords = {
+    [Name in DbExactKeys]: GettablePossibleEmpty<ExactRecords[Name]>;
+};
+
+declare type DbProvidedRecord = {
+    [Name in ProvidedExactKeys as `${Name}${string}`]: GettablePossibleEmpty<ExactRecords[Name]>;
+};
+
 declare interface DeepstreamDomainRecords {
     ":deepstream.replicate": DeepstreamDomainReplicateRecord;
 }
@@ -432,7 +446,13 @@ declare interface DesignViewRow<Id = string, Key = string, Value = void> {
 
 declare type DomainRecords = AssetDomainRecords & BundleDomainRecords & CloneDomainRecords & CommentReactionDomainRecords & CommentReadMarkDomainRecords & CommentDomainRecords & ConnectionDomainRecords & ContactDomainRecords & DeepstreamDomainRecords & DesignDomainRecords & EditDomainRecords & EventDomainRecords & FileDomainRecords & GeneralDomainRecords & MediaDomainRecords & MonitorDomainRecords & PanelDomainRecords & PermissionDomainRecords & PipelinePresetDomainRecords & PipelineDomainRecords & PlanningDomainRecords & PrompterDomainRecords & PublishDomainRecords & PublishedDomainRecords & RenderPresetDomainRecords & RenderDomainRecords & RevsDomainRecords & RoleDomainRecords & ScriptDomainRecords & SearchDomainRecords & SettingsDomainRecords & StoryboardDomainRecords & SubtitleStyleDomainRecords & SubtitleDomainRecords & TemplateDomainRecords & UserNotificationStatusDomainRecords & UserNotificationDomainRecords & UserDomainRecords;
 
-declare type Domains = Exclude<keyof DomainRecords, ":design">;
+declare interface DomainRows {
+    rows: string[];
+}
+
+declare type DomainRowsRecords = {
+    [Domain in DbDomainKeys as Domain]: GettablePossibleEmpty<DomainRows>;
+};
 
 declare type Dynamic = false | string[];
 
@@ -455,6 +475,36 @@ declare interface ElementNodeContent {
     children: TextNodeContent[];
 }
 
+/**
+ Represents a strictly empty plain object, the `{}` value.
+
+ When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+ @example
+ ```
+ import type {EmptyObject} from 'type-fest';
+
+ // The following illustrates the problem with `{}`.
+ const foo1: {} = {}; // Pass
+ const foo2: {} = []; // Pass
+ const foo3: {} = 42; // Pass
+ const foo4: {} = {a: 1}; // Pass
+
+ // With `EmptyObject` only the first case is valid.
+ const bar1: EmptyObject = {}; // Pass
+ const bar2: EmptyObject = 42; // Fail
+ const bar3: EmptyObject = []; // Fail
+ const bar4: EmptyObject = {a: 1}; // Fail
+ ```
+
+ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+ @category Object
+ */
+declare type EmptyObject = {[emptyObjectSymbol]?: never};
+
+declare const emptyObjectSymbol: unique symbol;
+
 declare interface EmptyPublishRecord {
     type: null;
     asset?: string | null;
@@ -806,6 +856,10 @@ declare interface GeneralTitleRecord {
 
 declare type Get<Data, Path extends string> = Path extends keyof Data ? Data[Path] : unknown;
 
+declare type GettablePossibleEmpty<Data> = keyof Data extends never ? EmptyObject : Partial<Data> extends Data ? Data : SingleKeyObject<Data> extends never ? Data | EmptyObject : {
+    [K in keyof Data]+?: Data[K];
+};
+
 declare interface HeadingNodeContent extends ElementNodeContent {
     type: "heading";
     tag: "h1" | "h2" | "h3";
@@ -815,6 +869,48 @@ declare interface HorizontalRuleContent {
     type: "horizontalrule";
 }
 
+/**
+ An if-else-like type that resolves depending on whether the given type is `{}`.
+
+ @see {@link IsEmptyObject}
+
+ @example
+ ```
+ import type {IfEmptyObject} from 'type-fest';
+
+ type ShouldBeTrue = IfEmptyObject<{}>;
+ //=> true
+
+ type ShouldBeBar = IfEmptyObject<{key: any}, 'foo', 'bar'>;
+ //=> 'bar'
+ ```
+
+ @category Type Guard
+ @category Utilities
+ */
+declare type IfEmptyObject<
+	T,
+	TypeIfEmptyObject = true,
+	TypeIfNotEmptyObject = false,
+> = IsEmptyObject<T> extends true ? TypeIfEmptyObject : TypeIfNotEmptyObject;
+
+/**
+ Returns a `boolean` for whether the type is strictly equal to an empty plain object, the `{}` value.
+
+ @example
+ ```
+ import type {IsEmptyObject} from 'type-fest';
+
+ type Pass = IsEmptyObject<{}>; //=> true
+ type Fail = IsEmptyObject<[]>; //=> false
+ type Fail = IsEmptyObject<null>; //=> false
+ ```
+
+ @see EmptyObject
+ @category Object
+ */
+declare type IsEmptyObject<T> = T extends EmptyObject ? true : false;
+
 declare type IsoTimestamp = string;
 
 declare type JsonPrimitive = string | number | boolean | null;
@@ -823,6 +919,14 @@ declare type JsonValue = JsonPrimitive | JsonValue[] | {
     [key: string]: JsonValue;
 };
 
+declare type KeyedDomainRecords = {
+    [Domain in DbDomainKeys as `${string}${Domain}`]: GettablePossibleEmpty<DomainRecords[Domain]>;
+};
+
+declare type KeyedProvidedDomainRecords = {
+    [Domain in ProvidedDomainKeys as `${string}${Domain}${string}`]: GettablePossibleEmpty<DomainRecords[Domain]>;
+};
+
 declare interface KeymapSetting {
     title?: string;
     sequence?: string;
@@ -1648,6 +1752,10 @@ declare interface PrompterDomainRecords {
     ":prompter": PrompterDomainRecord;
 }
 
+declare type ProvidedDomainKeys = keyof DomainRecords & `${string}?`;
+
+declare type ProvidedExactKeys = keyof ExactRecords & `${string}?`;
+
 declare interface ProvidedPermissionRecord {
     permissions: PermissionRecordPermisson[];
 }
@@ -1729,11 +1837,7 @@ number,
 number
 ];
 
-declare type Records = {
-    [Property in Domains as `${string}${Property}`]: DomainRecords[Property];
-} & {
-    [Property in keyof DesignDomainRecords as `${string}${Property}${string}`]: DesignDomainRecords[Property];
-} & ExactRecords;
+declare type Records = KeyedDomainRecords & KeyedProvidedDomainRecords & DomainRowsRecords & DbExactRecords & DbProvidedRecord;
 
 declare type RecordState = RecordStateNumber | RecordStateString;
 
@@ -2472,6 +2576,33 @@ declare interface SettingsPanelStoreTab extends ModuleTabsSettingsValue {
 
 declare type SettingsRecord = Settings;
 
+/**
+ Create a type that only accepts an object with a single key.
+
+ @example
+ ```
+ import type {SingleKeyObject} from 'type-fest';
+
+ const someFunction = <T>(parameter: SingleKeyObject<T>) => {};
+
+ someFunction({
+ 	value: true
+ });
+
+ someFunction({
+ 	value: true,
+ 	otherKey: true
+ });
+ // Error: Argument of type '{value: boolean; otherKey: boolean}' is not assignable to parameter of type 'never'.ts(2345)
+ ```
+
+ @category Object
+ */
+declare type SingleKeyObject<ObjectType> =
+	IsUnion<keyof ObjectType> extends true
+		? never
+		: IfEmptyObject<ObjectType, never, ObjectType>;
+
 declare type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
 
 declare interface StorageLocationsRecord {

package/dist/records/index.d.ts

@@ -1,11 +1,3 @@
-import type { DomainRecords, DesignDomainRecords } from './domains/index.ts';
-import type { ExactRecords } from './exact/index.ts';
 export * from './domains/index.ts';
 export * from './exact/index.ts';
-export type Domains = Exclude<keyof DomainRecords, ":design">;
-export type Records = {
-    [Property in Domains as `${string}${Property}`]: DomainRecords[Property];
-} & {
-    [Property in keyof DesignDomainRecords as `${string}${Property}${string}`]: DesignDomainRecords[Property];
-} & ExactRecords;
-export { RecordNameToType } from './utils.ts';
+export type { RecordNameToType, Records } from './utils.ts';

package/dist/records/utils.d.ts

@@ -1,6 +1,26 @@
 import type { EmptyObject, SingleKeyObject } from 'type-fest';
 import type { DomainRecords, DomainRows, ExactRecords } from './index.ts';
-export type RecordNameToType<T extends string> = T extends keyof ExactRecords ? GettablePossibleEmpty<ExactRecords[T]> : T extends `:${string}` ? GettablePossibleEmpty<DomainRows> : T extends `${string}:${infer Domain}?${string}` ? `:${Domain}?` extends keyof DomainRecords ? GettablePossibleEmpty<DomainRecords[`:${Domain}?`]> : unknown : T extends `${string}:${infer Pattern}` ? `:${Pattern}` extends keyof DomainRecords ? GettablePossibleEmpty<DomainRecords[`:${Pattern}`]> : unknown : unknown;
+type ProvidedDomainKeys = keyof DomainRecords & `${string}?`;
+type DbDomainKeys = Exclude<keyof DomainRecords, ProvidedDomainKeys>;
+type ProvidedExactKeys = keyof ExactRecords & `${string}?`;
+type DbExactKeys = Exclude<keyof ExactRecords, ProvidedExactKeys>;
+type KeyedDomainRecords = {
+    [Domain in DbDomainKeys as `${string}${Domain}`]: GettablePossibleEmpty<DomainRecords[Domain]>;
+};
+type KeyedProvidedDomainRecords = {
+    [Domain in ProvidedDomainKeys as `${string}${Domain}${string}`]: GettablePossibleEmpty<DomainRecords[Domain]>;
+};
+type DomainRowsRecords = {
+    [Domain in DbDomainKeys as Domain]: GettablePossibleEmpty<DomainRows>;
+};
+type DbExactRecords = {
+    [Name in DbExactKeys]: GettablePossibleEmpty<ExactRecords[Name]>;
+};
+type DbProvidedRecord = {
+    [Name in ProvidedExactKeys as `${Name}${string}`]: GettablePossibleEmpty<ExactRecords[Name]>;
+};
+export type Records = KeyedDomainRecords & KeyedProvidedDomainRecords & DomainRowsRecords & DbExactRecords & DbProvidedRecord;
+export type RecordNameToType<T extends string> = T extends keyof Records ? Records[T] : unknown;
 declare const providedRecordSymbol: unique symbol;
 export type ProvidedRecord<T> = T & {
     [providedRecordSymbol]: never;

package/dist/records/validate/assert-guard.js

@@ -1402,7 +1402,7 @@ function _assertGuardExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assertGuard",
                     path: _path + ".languages",
                     expected: "(Record<string, string> | undefined)",
@@ -1452,7 +1452,7 @@ function _assertGuardExactRecord(name, input) {
                     path: _path + ".asset",
                     expected: "(string | undefined)",
                     value: input.asset
-                }, _errorFactory)) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }, _errorFactory)) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assertGuard",
                     path: _path + ".weight",
                     expected: "(\"bold\" | \"normal\" | undefined)",
@@ -1485,7 +1485,7 @@ function _assertGuardExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assertGuard",
                     path: _path + ".languages",
                     expected: "(Record<string, string> | undefined)",
@@ -1535,7 +1535,7 @@ function _assertGuardExactRecord(name, input) {
                     path: _path + ".asset",
                     expected: "(string | undefined)",
                     value: input.asset
-                }, _errorFactory)) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }, _errorFactory)) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assertGuard",
                     path: _path + ".weight",
                     expected: "(\"bold\" | \"normal\" | undefined)",
@@ -12575,10 +12575,10 @@ function _assertGuardDomainRecord(domain, input) {
                 }; })()(input);
             }
             case ":script.content?": {
-                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("text" === input.type || "autolink" === input.type || "link" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
+                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("link" === input.type || "text" === input.type || "autolink" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
                     if ("event" === input.type)
                         return _io1(input);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _io2(input);
                     else if ("listitem" === input.type)
                         return _io3(input);
@@ -12651,7 +12651,7 @@ function _assertGuardDomainRecord(domain, input) {
                     path: _path + ".children",
                     expected: "Array<EventNodeContent>",
                     value: input.children
-                }, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("text" === input.type || "autolink" === input.type || "link" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("link" === input.type || "text" === input.type || "autolink" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assertGuard",
                     path: _path + ".type",
                     expected: "(\"autolink\" | \"link\" | \"text\")",
@@ -12854,7 +12854,7 @@ function _assertGuardDomainRecord(domain, input) {
                 }, _errorFactory); const _au0 = (input, _path, _exceptionable = true) => (() => {
                     if ("event" === input.type)
                         return _ao1(input, _path, true && _exceptionable);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _ao2(input, _path, true && _exceptionable);
                     else if ("listitem" === input.type)
                         return _ao3(input, _path, true && _exceptionable);

package/dist/records/validate/assert.js

@@ -1417,7 +1417,7 @@ function _assertExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".languages",
                     expected: "(Record<string, string> | undefined)",
@@ -1467,7 +1467,7 @@ function _assertExactRecord(name, input) {
                     path: _path + ".asset",
                     expected: "(string | undefined)",
                     value: input.asset
-                }, _errorFactory)) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }, _errorFactory)) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".weight",
                     expected: "(\"bold\" | \"normal\" | undefined)",
@@ -1501,7 +1501,7 @@ function _assertExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".languages",
                     expected: "(Record<string, string> | undefined)",
@@ -1551,7 +1551,7 @@ function _assertExactRecord(name, input) {
                     path: _path + ".asset",
                     expected: "(string | undefined)",
                     value: input.asset
-                }, _errorFactory)) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }, _errorFactory)) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".weight",
                     expected: "(\"bold\" | \"normal\" | undefined)",
@@ -12687,10 +12687,10 @@ function _assertDomainRecord(domain, input) {
                 }; })()(input);
             }
             case ":script.content?": {
-                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("text" === input.type || "autolink" === input.type || "link" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
+                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("link" === input.type || "text" === input.type || "autolink" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
                     if ("event" === input.type)
                         return _io1(input);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _io2(input);
                     else if ("listitem" === input.type)
                         return _io3(input);
@@ -12763,7 +12763,7 @@ function _assertDomainRecord(domain, input) {
                     path: _path + ".children",
                     expected: "Array<EventNodeContent>",
                     value: input.children
-                }, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("text" === input.type || "autolink" === input.type || "link" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                }, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("link" === input.type || "text" === input.type || "autolink" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
                     method: "typia.assert",
                     path: _path + ".type",
                     expected: "(\"autolink\" | \"link\" | \"text\")",
@@ -12966,7 +12966,7 @@ function _assertDomainRecord(domain, input) {
                 }, _errorFactory); const _au0 = (input, _path, _exceptionable = true) => (() => {
                     if ("event" === input.type)
                         return _ao1(input, _path, true && _exceptionable);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _ao2(input, _path, true && _exceptionable);
                     else if ("listitem" === input.type)
                         return _ao3(input, _path, true && _exceptionable);

package/dist/records/validate/is.js

@@ -105,7 +105,7 @@ function _isExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); })()(input);
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); })()(input);
             }
             case "media.subtitles?": {
                 return (() => { const _io0 = input => (undefined === input.languages || "object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) && _io1(input.languages)) && (undefined === input.fontFaces || Array.isArray(input.fontFaces) && input.fontFaces.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io1 = input => Object.keys(input).every(key => {
@@ -113,7 +113,7 @@ function _isExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); })()(input);
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); })()(input);
             }
             case "media.transcribe?": {
                 return (() => { const _io0 = input => "object" === typeof input.engines && null !== input.engines && false === Array.isArray(input.engines) && _io1(input.engines) && ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) && _io1(input.languages)) && (undefined === input.translate || "object" === typeof input.translate && null !== input.translate && _io2(input.translate)); const _io1 = input => Object.keys(input).every(key => {
@@ -845,10 +845,10 @@ function _isDomainRecord(domain, input) {
                 }); const _io4 = input => "string" === typeof input.type && "number" === typeof input.version && (undefined === input.$ || "object" === typeof input.$ && null !== input.$ && false === Array.isArray(input.$) && _io3(input.$)); return input => "object" === typeof input && null !== input && _io0(input); })()(input);
             }
             case ":script.content?": {
-                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("text" === input.type || "autolink" === input.type || "link" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
+                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("link" === input.type || "text" === input.type || "autolink" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
                     if ("event" === input.type)
                         return _io1(input);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _io2(input);
                     else if ("listitem" === input.type)
                         return _io3(input);

package/dist/records/validate/schemas.js

@@ -1219,10 +1219,10 @@ function _schemasExactRecord(name) {
                                     weight: {
                                         oneOf: [
                                             {
-                                                "const": "normal"
+                                                "const": "bold"
                                             },
                                             {
-                                                "const": "bold"
+                                                "const": "normal"
                                             }
                                         ]
                                     },
@@ -1291,10 +1291,10 @@ function _schemasExactRecord(name) {
                                     weight: {
                                         oneOf: [
                                             {
-                                                "const": "normal"
+                                                "const": "bold"
                                             },
                                             {
-                                                "const": "bold"
+                                                "const": "normal"
                                             }
                                         ]
                                     },
@@ -10429,13 +10429,13 @@ function _schemasDomainRecord(domain) {
                                     type: {
                                         oneOf: [
                                             {
-                                                "const": "text"
+                                                "const": "link"
                                             },
                                             {
-                                                "const": "autolink"
+                                                "const": "text"
                                             },
                                             {
-                                                "const": "link"
+                                                "const": "autolink"
                                             }
                                         ]
                                     },

package/dist/records/validate/stringify.js

@@ -304,7 +304,7 @@ function _stringifyExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => _so0(input); })()(input);
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => _so0(input); })()(input);
             }
             case "media.subtitles?": {
                 return (() => { const _so0 = input => `{${__typia_transform__jsonStringifyTail._jsonStringifyTail(`${undefined === input.languages ? "" : `"languages":${undefined !== input.languages ? _so1(input.languages) : undefined},`}${undefined === input.fontFaces ? "" : `"fontFaces":${undefined !== input.fontFaces ? `[${input.fontFaces.map(elem => _so2(elem)).join(",")}]` : undefined}`}`)}}`; const _so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
@@ -313,7 +313,7 @@ function _stringifyExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => _so0(input); })()(input);
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); return input => _so0(input); })()(input);
             }
             case "media.transcribe?": {
                 return (() => { const _so0 = input => `{${undefined === input.translate ? "" : `"translate":${undefined !== input.translate ? _so2(input.translate) : undefined},`}"engines":${_so1(input.engines)},"languages":${_so1(input.languages)}}`; const _so1 = input => `{${Object.entries(input).map(([key, value]) => { if (undefined === value)
@@ -1663,7 +1663,7 @@ function _stringifyDomainRecord(domain, input) {
                 return (() => { const _so0 = input => `{"nodes":${`[${input.nodes.map(elem => _su0(elem)).join(",")}]`}}`; const _so1 = input => `{"type":${"\"" + input.type + "\""},"id":${__typia_transform__jsonStringifyString._jsonStringifyString(input.id)},"mixin":${__typia_transform__jsonStringifyString._jsonStringifyString(input.mixin)},"children":${`[${input.children.map(elem => _so1(elem)).join(",")}]`}}`; const _so2 = input => `{${undefined === input.style ? "" : `"style":${undefined !== input.style ? __typia_transform__jsonStringifyString._jsonStringifyString(input.style) : undefined},`}${undefined === input.format ? "" : `"format":${undefined !== input.format ? input.format : undefined},`}"type":${"\"" + input.type + "\""},"text":${__typia_transform__jsonStringifyString._jsonStringifyString(input.text)}}`; const _so3 = input => `{${undefined === input.checked ? "" : `"checked":${undefined !== input.checked ? input.checked : undefined},`}"type":${"\"" + input.type + "\""},"value":${input.value},"children":${`[${input.children.map(elem => _so2(elem)).join(",")}]`}}`; const _so4 = input => `{"type":${"\"" + input.type + "\""},"listType":${"\"" + input.listType + "\""},"tag":${"\"" + input.tag + "\""},"children":${`[${input.children.map(elem => _so3(elem)).join(",")}]`}}`; const _so5 = input => `{"type":${"\"" + input.type + "\""},"children":${`[${input.children.map(elem => _so2(elem)).join(",")}]`}}`; const _so6 = input => `{"type":${"\"" + input.type + "\""},"children":${`[${input.children.map(elem => _so2(elem)).join(",")}]`}}`; const _so7 = input => `{"type":${"\"" + input.type + "\""},"tag":${"\"" + input.tag + "\""},"children":${`[${input.children.map(elem => _so2(elem)).join(",")}]`}}`; const _so8 = input => `{"type":${"\"" + input.type + "\""},"children":${`[${input.children.map(elem => _so2(elem)).join(",")}]`}}`; const _so9 = input => `{"type":${"\"" + input.type + "\""}}`; const _su0 = input => (() => {
                     if ("event" === input.type)
                         return _so1(input);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _so2(input);
                     else if ("listitem" === input.type)
                         return _so3(input);
@@ -1685,10 +1685,10 @@ function _stringifyDomainRecord(domain, input) {
                             expected: "(EventNodeContent | TextNodeContent | ListItemNodeContent | ListNodeContent | QuoteNodeContent | CommentNodeContent | ParagraphNodeContent | HeadingNodeContent | HorizontalRuleContent)",
                             value: input
                         });
-                })(); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("text" === input.type || "autolink" === input.type || "link" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
+                })(); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("link" === input.type || "text" === input.type || "autolink" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
                     if ("event" === input.type)
                         return _io1(input);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _io2(input);
                     else if ("listitem" === input.type)
                         return _io3(input);

package/dist/records/validate/validate-equals.js

@@ -2328,7 +2328,7 @@ function _validateEqualsExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = (input, _exceptionable = true) => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+                }); const _io2 = (input, _exceptionable = true) => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
                     if (["family", "asset", "weight", "style"].some(prop => key === prop))
                         return true;
                     const value = input[key];
@@ -2392,7 +2392,7 @@ function _validateEqualsExactRecord(name, input) {
                         path: _path + ".asset",
                         expected: "(string | undefined)",
                         value: input.asset
-                    }), undefined === input.weight || "normal" === input.weight || "bold" === input.weight || _report(_exceptionable, {
+                    }), undefined === input.weight || "bold" === input.weight || "normal" === input.weight || _report(_exceptionable, {
                         path: _path + ".weight",
                         expected: "(\"bold\" | \"normal\" | undefined)",
                         value: input.weight
@@ -2458,7 +2458,7 @@ function _validateEqualsExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = (input, _exceptionable = true) => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+                }); const _io2 = (input, _exceptionable = true) => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
                     if (["family", "asset", "weight", "style"].some(prop => key === prop))
                         return true;
                     const value = input[key];
@@ -2522,7 +2522,7 @@ function _validateEqualsExactRecord(name, input) {
                         path: _path + ".asset",
                         expected: "(string | undefined)",
                         value: input.asset
-                    }), undefined === input.weight || "normal" === input.weight || "bold" === input.weight || _report(_exceptionable, {
+                    }), undefined === input.weight || "bold" === input.weight || "normal" === input.weight || _report(_exceptionable, {
                         path: _path + ".weight",
                         expected: "(\"bold\" | \"normal\" | undefined)",
                         value: input.weight
@@ -18908,7 +18908,7 @@ function _validateEqualsDomainRecord(domain, input) {
                     if (undefined === value)
                         return true;
                     return false;
-                })); const _io2 = (input, _exceptionable = true) => ("text" === input.type || "autolink" === input.type || "link" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+                })); const _io2 = (input, _exceptionable = true) => ("link" === input.type || "text" === input.type || "autolink" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
                     if (["type", "text", "style", "format"].some(prop => key === prop))
                         return true;
                     const value = input[key];
@@ -18967,7 +18967,7 @@ function _validateEqualsDomainRecord(domain, input) {
                 })); const _iu0 = (input, _exceptionable = true) => (() => {
                     if ("event" === input.type)
                         return _io1(input, true && _exceptionable);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _io2(input, true && _exceptionable);
                     else if ("listitem" === input.type)
                         return _io3(input, true && _exceptionable);
@@ -19061,7 +19061,7 @@ function _validateEqualsDomainRecord(domain, input) {
                                 "Please remove the property next time."
                             ].join("\n")
                         });
-                    }).every(flag => flag))].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["text" === input.type || "autolink" === input.type || "link" === input.type || _report(_exceptionable, {
+                    }).every(flag => flag))].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["link" === input.type || "text" === input.type || "autolink" === input.type || _report(_exceptionable, {
                         path: _path + ".type",
                         expected: "(\"autolink\" | \"link\" | \"text\")",
                         value: input.type
@@ -19352,7 +19352,7 @@ function _validateEqualsDomainRecord(domain, input) {
                     }).every(flag => flag))].every(flag => flag); const _vu0 = (input, _path, _exceptionable = true) => (() => {
                     if ("event" === input.type)
                         return _vo1(input, _path, true && _exceptionable);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _vo2(input, _path, true && _exceptionable);
                     else if ("listitem" === input.type)
                         return _vo3(input, _path, true && _exceptionable);

package/dist/records/validate/validate.js

@@ -1378,7 +1378,7 @@ function _validateExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || _report(_exceptionable, {
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || _report(_exceptionable, {
                         path: _path + ".languages",
                         expected: "(Record<string, string> | undefined)",
                         value: input.languages
@@ -1419,7 +1419,7 @@ function _validateExactRecord(name, input) {
                         path: _path + ".asset",
                         expected: "(string | undefined)",
                         value: input.asset
-                    }), undefined === input.weight || "normal" === input.weight || "bold" === input.weight || _report(_exceptionable, {
+                    }), undefined === input.weight || "bold" === input.weight || "normal" === input.weight || _report(_exceptionable, {
                         path: _path + ".weight",
                         expected: "(\"bold\" | \"normal\" | undefined)",
                         value: input.weight
@@ -1462,7 +1462,7 @@ function _validateExactRecord(name, input) {
                     if (undefined === value)
                         return true;
                     return "string" === typeof value;
-                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "normal" === input.weight || "bold" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || _report(_exceptionable, {
+                }); const _io2 = input => "string" === typeof input.family && (undefined === input.asset || "string" === typeof input.asset) && (undefined === input.weight || "bold" === input.weight || "normal" === input.weight) && (undefined === input.style || "normal" === input.style || "italic" === input.style); const _vo0 = (input, _path, _exceptionable = true) => [undefined === input.languages || ("object" === typeof input.languages && null !== input.languages && false === Array.isArray(input.languages) || _report(_exceptionable, {
                         path: _path + ".languages",
                         expected: "(Record<string, string> | undefined)",
                         value: input.languages
@@ -1503,7 +1503,7 @@ function _validateExactRecord(name, input) {
                         path: _path + ".asset",
                         expected: "(string | undefined)",
                         value: input.asset
-                    }), undefined === input.weight || "normal" === input.weight || "bold" === input.weight || _report(_exceptionable, {
+                    }), undefined === input.weight || "bold" === input.weight || "normal" === input.weight || _report(_exceptionable, {
                         path: _path + ".weight",
                         expected: "(\"bold\" | \"normal\" | undefined)",
                         value: input.weight
@@ -12004,10 +12004,10 @@ function _validateDomainRecord(domain, input) {
                 }; })()(input);
             }
             case ":script.content?": {
-                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("text" === input.type || "autolink" === input.type || "link" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
+                return (() => { const _io0 = input => Array.isArray(input.nodes) && input.nodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)); const _io1 = input => "event" === input.type && "string" === typeof input.id && "string" === typeof input.mixin && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io2 = input => ("link" === input.type || "text" === input.type || "autolink" === input.type) && "string" === typeof input.text && (undefined === input.style || "string" === typeof input.style) && (undefined === input.format || "number" === typeof input.format); const _io3 = input => "listitem" === input.type && "number" === typeof input.value && (undefined === input.checked || "boolean" === typeof input.checked) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io4 = input => "list" === input.type && ("number" === input.listType || "bullet" === input.listType || "check" === input.listType) && ("ul" === input.tag || "ol" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io3(elem))); const _io5 = input => "paragraph" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io6 = input => "comment" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io7 = input => "heading" === input.type && ("h1" === input.tag || "h2" === input.tag || "h3" === input.tag) && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io8 = input => "quote" === input.type && (Array.isArray(input.children) && input.children.every(elem => "object" === typeof elem && null !== elem && _io2(elem))); const _io9 = input => "horizontalrule" === input.type; const _iu0 = input => (() => {
                     if ("event" === input.type)
                         return _io1(input);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _io2(input);
                     else if ("listitem" === input.type)
                         return _io3(input);
@@ -12069,7 +12069,7 @@ function _validateDomainRecord(domain, input) {
                         path: _path + ".children",
                         expected: "Array<EventNodeContent>",
                         value: input.children
-                    })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["text" === input.type || "autolink" === input.type || "link" === input.type || _report(_exceptionable, {
+                    })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["link" === input.type || "text" === input.type || "autolink" === input.type || _report(_exceptionable, {
                         path: _path + ".type",
                         expected: "(\"autolink\" | \"link\" | \"text\")",
                         value: input.type
@@ -12232,7 +12232,7 @@ function _validateDomainRecord(domain, input) {
                     })].every(flag => flag); const _vu0 = (input, _path, _exceptionable = true) => (() => {
                     if ("event" === input.type)
                         return _vo1(input, _path, true && _exceptionable);
-                    else if ("text" === input.type || "autolink" === input.type || "link" === input.type)
+                    else if ("link" === input.type || "text" === input.type || "autolink" === input.type)
                         return _vo2(input, _path, true && _exceptionable);
                     else if ("listitem" === input.type)
                         return _vo3(input, _path, true && _exceptionable);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/types",
-  "version": "23.0.46",
+  "version": "23.0.47",
   "description": "TypeScript types to be shared between nxtedition packages.",
   "license": "MIT",
   "type": "module",