@strapi/strapi 4.11.0-exp.push-transfer-push-stuck → 4.11.1-beta.0

package/lib/types/core/attributes/component.d.ts

@@ -1,38 +1,33 @@
-import { Attribute, ConfigurableOption, MinMaxOption, PrivateOption, RequiredOption } from './base';
-import { GetAttributesValues } from './utils';
+import type { Common, Attribute, Utils } from '@strapi/strapi';
 
-export interface ComponentAttributeProperties<
-  // Targeted component
-  T extends Strapi.ComponentUIDs,
-  // Repeatable
-  R extends boolean = false
+export interface ComponentProperties<
+  TComponentUID extends Common.UID.Component,
+  TRepeatable extends Utils.Expression.BooleanValue = Utils.Expression.False
 > {
-  component: T;
-  repeatable?: R;
+  component: TComponentUID;
+  repeatable?: TRepeatable;
 }
 
-export type ComponentAttribute<
-  // Targeted component
-  T extends Strapi.ComponentUIDs,
-  // Repeatable
-  R extends boolean = false
-> = Attribute<'component'> &
+export type Component<
+  TComponentUID extends Common.UID.Component = Common.UID.Component,
+  TRepeatable extends Utils.Expression.BooleanValue = Utils.Expression.False
+> = Attribute.OfType<'component'> &
   // Component Properties
-  ComponentAttributeProperties<T, R> &
+  ComponentProperties<TComponentUID, TRepeatable> &
   // Options
-  ConfigurableOption &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type ComponentValue<
-  T extends Strapi.ComponentUIDs,
-  R extends boolean
-> = GetAttributesValues<T> extends infer V ? (R extends true ? V[] : V) : never;
-
-export type GetComponentAttributeValue<T extends Attribute> = T extends ComponentAttribute<
-  infer U,
-  infer R
->
-  ? ComponentValue<U, R>
+  TComponentUID extends Common.UID.Component,
+  TRepeatable extends Utils.Expression.BooleanValue
+> = Attribute.GetValues<TComponentUID> extends infer TValues
+  ? Utils.Expression.If<TRepeatable, TValues[], TValues>
   : never;
+
+export type GetComponentValue<TAttribute extends Attribute.Attribute> =
+  TAttribute extends Component<infer TComponentUID, infer TRepeatable>
+    ? ComponentValue<TComponentUID, TRepeatable>
+    : never;

package/lib/types/core/attributes/date-time.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type DateTimeAttribute = Attribute<'datetime'> &
+export type DateTime = Attribute.OfType<'datetime'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<DateTimeValue> &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<DateTimeValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type DateTimeValue = string;
 
-export type GetDateTimeAttributeValue<T extends Attribute> = T extends DateTimeAttribute
+export type GetDateTimeValue<T extends Attribute.Attribute> = T extends DateTime
   ? DateTimeValue
   : never;

package/lib/types/core/attributes/date.d.ts

@@ -1,22 +1,13 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type DateAttribute = Attribute<'date'> &
+export type Date = Attribute.OfType<'date'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<DateValue> &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<DateValue> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type DateValue = Date;
 
-export type GetDateAttributeValue<T extends Attribute> = T extends DateAttribute
-  ? DateValue
-  : never;
+export type GetDateValue<T extends Attribute.Attribute> = T extends Date ? DateValue : never;

package/lib/types/core/attributes/decimal.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type DecimalAttribute = Attribute<'decimal'> &
+export type Decimal = Attribute.OfType<'decimal'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<DecimalValue> &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<DecimalValue> &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type DecimalValue = number;
 
-export type GetDecimalAttributeValue<T extends Attribute> = T extends DecimalAttribute
+export type GetDecimalValue<T extends Attribute.Attribute> = T extends Decimal
   ? DecimalValue
   : never;

package/lib/types/core/attributes/dynamic-zone.d.ts

@@ -1,29 +1,26 @@
-import { SchemaUID, GetArrayValues } from '../../utils';
-import { Attribute, ConfigurableOption, MinMaxOption, RequiredOption } from './base';
-import { GetAttributesValues } from './utils';
+import type { Utils, Attribute, Common } from '@strapi/strapi';
 
-export interface DynamicZoneAttributeProperties<T extends Strapi.ComponentUIDs[] = []> {
-  components: T;
+export interface DynamicZoneProperties<TComponentsUIDs extends Common.UID.Component[]> {
+  components: TComponentsUIDs;
 }
 
-export type DynamicZoneAttribute<T extends Strapi.ComponentUIDs[] = []> = Attribute<'dynamiczone'> &
-  // Properties
-  DynamicZoneAttributeProperties<T> &
-  // Options
-  ConfigurableOption &
-  MinMaxOption &
-  RequiredOption;
+export type DynamicZone<TComponentsUIDs extends Common.UID.Component[] = Common.UID.Component[]> =
+  Attribute.OfType<'dynamiczone'> &
+    // Properties
+    DynamicZoneProperties<TComponentsUIDs> &
+    // Options
+    Attribute.ConfigurableOption &
+    Attribute.MinMaxOption &
+    Attribute.RequiredOption;
 
-type DynamicZoneValue<T extends Strapi.ComponentUIDs[]> = Array<
-  GetArrayValues<T> extends infer P
-    ? P extends SchemaUID
-      ? GetAttributesValues<P> & { __component: P }
+type DynamicZoneValue<TComponentsUIDs extends Common.UID.Component[]> = Array<
+  // Extract tuple values to a component uid union type
+  Utils.Array.Values<TComponentsUIDs> extends infer TComponentUID
+    ? TComponentUID extends Common.UID.Component
+      ? Attribute.GetValues<TComponentUID> & { __component: TComponentUID }
       : never
     : never
 >;
 
-export type GetDynamicZoneAttributeValue<T extends Attribute> = T extends DynamicZoneAttribute<
-  infer U
->
-  ? DynamicZoneValue<U>
-  : never;
+export type GetDynamicZoneValue<TAttribute extends Attribute.Attribute> =
+  TAttribute extends DynamicZone<infer TComponentsUIDs> ? DynamicZoneValue<TComponentsUIDs> : never;

package/lib/types/core/attributes/email.d.ts

@@ -1,24 +1,14 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-  UniqueOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type EmailAttribute = Attribute<'email'> &
+export type Email = Attribute.OfType<'email'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<EmailValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption &
-  UniqueOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<EmailValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption &
+  Attribute.UniqueOption;
 
 export type EmailValue = string;
 
-export type GetEmailAttributeValue<T extends Attribute> = T extends EmailAttribute
-  ? EmailValue
-  : never;
+export type GetEmailValue<T extends Attribute.Attribute> = T extends Email ? EmailValue : never;

package/lib/types/core/attributes/enumeration.d.ts

@@ -1,28 +1,18 @@
-import { GetArrayValues } from '../../utils';
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute, Utils } from '@strapi/strapi';
 
-export interface EnumerationAttributeProperties<T extends string[] = []> {
-  enum: T;
+export interface EnumerationProperties<TValues extends string[] = []> {
+  enum: TValues;
 }
 
-export type EnumerationAttribute<T extends string[] = []> = Attribute<'enumeration'> &
-  EnumerationAttributeProperties<T> &
+export type Enumeration<TValues extends string[] = []> = Attribute.OfType<'enumeration'> &
+  EnumerationProperties<TValues> &
   // Options
-  ConfigurableOption &
-  DefaultOption<T> &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<TValues> &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
-export type EnumerationValue<T extends string[]> = GetArrayValues<T>;
+export type EnumerationValue<TValues extends string[]> = Utils.Array.Values<TValues>;
 
-export type GetEnumerationAttributeValue<T extends Attribute> = T extends EnumerationAttribute<
-  infer U
->
-  ? EnumerationValue<U>
-  : never;
+export type GetEnumerationValue<TAttribute extends Attribute.Attribute> =
+  TAttribute extends Enumeration<infer TValues> ? EnumerationValue<TValues> : never;

package/lib/types/core/attributes/float.d.ts

@@ -1,22 +1,13 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type FloatAttribute = Attribute<'float'> &
+export type Float = Attribute.OfType<'float'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<FloatValue> &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<FloatValue> &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type FloatValue = number;
 
-export type GetFloatAttributeValue<T extends Attribute> = T extends FloatAttribute
-  ? FloatValue
-  : never;
+export type GetFloatValue<T extends Attribute.Attribute> = T extends Float ? FloatValue : never;

package/lib/types/core/attributes/integer.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type IntegerAttribute = Attribute<'integer'> &
+export type Integer = Attribute.OfType<'integer'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<IntegerValue> &
-  MinMaxOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<IntegerValue> &
+  Attribute.MinMaxOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type IntegerValue = number;
 
-export type GetIntegerAttributeValue<T extends Attribute> = T extends IntegerAttribute
+export type GetIntegerValue<T extends Attribute.Attribute> = T extends Integer
   ? IntegerValue
   : never;

package/lib/types/core/attributes/json.d.ts

@@ -1,14 +1,11 @@
-import { Attribute, ConfigurableOption, PrivateOption, RequiredOption } from './base';
-import { JSON } from './common';
+import type { Attribute } from '@strapi/strapi';
 
-export type JSONAttribute = Attribute<'json'> &
-  //Options
-  ConfigurableOption &
-  RequiredOption &
-  PrivateOption;
+export type JSON = Attribute.OfType<'json'> &
+  // Options
+  Attribute.ConfigurableOption &
+  Attribute.RequiredOption &
+  Attribute.PrivateOption;
 
-export type JsonValue = JSON;
+export type JsonValue<T extends object = object> = T;
 
-export type GetJsonAttributeValue<T extends Attribute> = T extends JSONAttribute
-  ? JsonValue
-  : never;
+export type GetJsonValue<T extends Attribute.Attribute> = T extends JSON ? JsonValue : never;

package/lib/types/core/attributes/media.d.ts

@@ -1,36 +1,34 @@
-import { Attribute, ConfigurableOption, PrivateOption, RequiredOption } from './base';
-import { Media } from './common';
+import type { Attribute, Utils } from '@strapi/strapi';
 
-export type AllowedMediaTypes = 'images' | 'videos' | 'files' | 'audios';
+export type MediaKind = 'images' | 'videos' | 'files' | 'audios';
 
-export interface MediaAttributeProperties<
-  // Media Type
-  T extends AllowedMediaTypes = undefined,
-  // Multiple
-  U extends boolean = false
+export interface MediaProperties<
+  TKind extends MediaKind | undefined = undefined,
+  TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False
 > {
-  allowedTypes?: T;
-  multiple?: U;
+  allowedTypes?: TKind;
+  multiple?: TMultiple;
 }
 
-export type MediaAttribute<
-  // Media Type
-  T extends AllowedMediaTypes = undefined,
-  // Multiple
-  U extends boolean = false
-> = Attribute<'media'> &
+export type Media<
+  TKind extends MediaKind | undefined = undefined,
+  TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False
+> = Attribute.OfType<'media'> &
   // Properties
-  MediaAttributeProperties<T, U> &
+  MediaProperties<TKind, TMultiple> &
   // Options
-  ConfigurableOption &
-  RequiredOption &
-  PrivateOption;
+  Attribute.ConfigurableOption &
+  Attribute.RequiredOption &
+  Attribute.PrivateOption;
 
-export type MediaValue<T extends boolean = false> = T extends true ? Media[] : Media;
+// TODO: Introduce a real type for the media values
+export type MediaValue<TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False> =
+  Utils.Expression.If<TMultiple, any[], any>;
 
-export type GetMediaAttributeValue<T extends Attribute> = T extends MediaAttribute<
-  infer _U,
-  infer S
+export type GetMediaValue<TAttribute extends Attribute.Attribute> = TAttribute extends Media<
+  // Unused as long as the media value is any
+  infer _TKind,
+  infer TMultiple
 >
-  ? MediaValue<S>
+  ? MediaValue<TMultiple>
   : never;

package/lib/types/core/attributes/password.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type PasswordAttribute = Attribute<'password'> &
+export type Password = Attribute.OfType<'password'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<PasswordValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<PasswordValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type PasswordValue = string;
 
-export type GetPasswordAttributeValue<T extends Attribute> = T extends PasswordAttribute
+export type GetPasswordValue<T extends Attribute.Attribute> = T extends Password
   ? PasswordValue
   : never;

package/lib/types/core/attributes/relation.d.ts

@@ -1,63 +1,111 @@
-import { SchemaUID } from '../../utils';
-import { Attribute, ConfigurableOption, PrivateOption } from './base';
-import { GetAttributesByType, GetAttributesValues } from './utils';
-
-export type BasicRelationsType = 'oneToOne' | 'oneToMany' | 'manyToOne' | 'manyToMany';
-export type PolymorphicRelationsType = 'morphToOne' | 'morphToMany' | 'morphOne' | 'morphMany';
-export type RelationsType = BasicRelationsType | PolymorphicRelationsType;
-
-export interface BasicRelationAttributeProperties<
-  S extends SchemaUID,
-  R extends RelationsType,
-  T extends SchemaUID
-> {
-  relation: R;
-  target: T;
-  inversedBy?: RelationsKeysFromTo<T, S>;
-  mappedBy?: RelationsKeysFromTo<T, S>;
-}
-
-export interface PolymorphicRelationAttributeProperties<R extends RelationsType> {
-  relation: R;
-}
+import type { Attribute, Common, Utils } from '@strapi/strapi';
 
-export type RelationAttribute<
-  S extends SchemaUID,
-  R extends RelationsType,
-  T extends R extends PolymorphicRelationsType ? never : SchemaUID = never
-> = Attribute<'relation'> &
+export type Relation<
+  // TODO: TOrigin was originally needed to infer precise attribute literal types by doing a reverse lookup
+  // on TTarget -> TOrigin relations. Due to errors because of Attribute.Any [relation] very generic
+  // representation, type mismatches were encountered and mappedBy/inversedBy are now regular strings.
+  // It is kept to allow for future iterations without breaking the current type API
+  TOrigin extends Common.UID.Schema = Common.UID.Schema,
+  TRelationKind extends RelationKind.Any = RelationKind.Any,
+  TTarget extends Common.UID.Schema = never
+> = Attribute.OfType<'relation'> &
   // Properties
-  (R extends BasicRelationsType
-    ? BasicRelationAttributeProperties<S, R, T>
-    : PolymorphicRelationAttributeProperties<R>) &
+  RelationProperties<TOrigin, TRelationKind, TTarget> &
   // Options
-  ConfigurableOption &
-  PrivateOption;
+  Attribute.ConfigurableOption &
+  Attribute.PrivateOption;
+
+export type RelationProperties<
+  _TOrigin extends Common.UID.Schema,
+  TRelationKind extends RelationKind.Any,
+  TTarget extends Common.UID.Schema
+> = Utils.Expression.MatchFirst<
+  [
+    Utils.Expression.Test<
+      Utils.Expression.Extends<TRelationKind, RelationKind.BiDirectional>,
+      {
+        relation: TRelationKind;
+        target: TTarget;
+        inversedBy?: string;
+        mappedBy?: string;
+      }
+    >,
+    Utils.Expression.Test<
+      Utils.Expression.Extends<TRelationKind, RelationKind.UniDirectional>,
+      { relation: TRelationKind }
+    >,
+    Utils.Expression.Test<
+      Utils.Expression.Extends<TRelationKind, RelationKind.MorphReference>,
+      {
+        relation: TRelationKind;
+        target: TTarget;
+        morphBy?: Utils.Guard.Never<
+          Attribute.GetKeysByType<TTarget, 'relation', { relation: RelationKind.MorphOwner }>,
+          string
+        >;
+      }
+    >
+  ]
+>;
 
 export type RelationsKeysFromTo<
-  TTarget extends SchemaUID,
-  TSource extends SchemaUID
-> = keyof PickRelationsFromTo<TTarget, TSource>;
+  TTarget extends Common.UID.Schema,
+  TOrigin extends Common.UID.Schema
+> = keyof PickRelationsFromTo<TTarget, TOrigin>;
 
 export type PickRelationsFromTo<
-  TTarget extends SchemaUID,
-  TSource extends SchemaUID
-> = GetAttributesByType<TTarget, 'relation', { target: TSource }>;
+  TTarget extends Common.UID.Schema,
+  TOrigin extends Common.UID.Schema
+> = Attribute.GetByType<TTarget, 'relation', { target: TOrigin }>;
 
 export type RelationPluralityModifier<
-  TRelation extends RelationsType,
-  TValue extends Record<string, unknown>
-> = TRelation extends `${string}Many` ? TValue[] : TValue;
+  TRelationKind extends RelationKind.Any,
+  TValue
+> = TRelationKind extends Utils.String.Suffix<string, 'Many'> ? TValue[] : TValue;
 
 export type RelationValue<
-  TRelation extends RelationsType,
-  TTarget extends SchemaUID
-> = RelationPluralityModifier<TRelation, GetAttributesValues<TTarget>>;
+  TRelationKind extends RelationKind.Any,
+  TTarget extends Common.UID.Schema
+> = RelationPluralityModifier<TRelationKind, Attribute.GetValues<TTarget>>;
 
-export type GetRelationAttributeValue<T extends Attribute> = T extends RelationAttribute<
-  infer _TSource,
-  infer TRelation,
+export type GetRelationValue<TAttribute extends Attribute.Attribute> = TAttribute extends Relation<
+  infer _TOrigin,
+  infer TRelationKind,
   infer TTarget
 >
-  ? RelationValue<TRelation, TTarget>
+  ? RelationValue<TRelationKind, TTarget>
   : never;
+
+export module RelationKind {
+  type GetOppositePlurality<TPlurality extends RelationKind.Left | RelationKind.Right> = {
+    one: 'many';
+    One: 'Many';
+    many: 'one';
+    Many: 'One';
+  }[TPlurality];
+
+  export type Plurality = 'one' | 'many';
+
+  export type Left = Lowercase<RelationKind.Plurality>;
+  export type Right = Capitalize<RelationKind.Plurality>;
+
+  export type MorphOwner = `morphTo${RelationKind.Right}`;
+  export type MorphReference = `morph${RelationKind.Right}`;
+  export type Morph = RelationKind.MorphOwner | RelationKind.MorphReference;
+
+  export type XWay = `${RelationKind.Left}Way`;
+
+  export type BiDirectional = `${RelationKind.Left}To${RelationKind.Right}`;
+  export type UniDirectional = RelationKind.Morph | RelationKind.XWay;
+
+  export type Any = RelationKind.BiDirectional | RelationKind.UniDirectional;
+
+  export type Reverse<TRelationKind extends RelationKind.Any> =
+    TRelationKind extends `${infer TLeft extends RelationKind.Left}To${infer TRight extends RelationKind.Right}`
+      ? Utils.Expression.If<
+          Utils.Expression.Extends<Uppercase<TLeft>, Uppercase<TRight>>,
+          TRelationKind,
+          `${GetOppositePlurality<TLeft>}To${GetOppositePlurality<TRight>}`
+        >
+      : TRelationKind;
+}

package/lib/types/core/attributes/richtext.d.ts

@@ -1,22 +1,15 @@
-import {
-  Attribute,
-  ConfigurableOption,
-  DefaultOption,
-  MinMaxLengthOption,
-  PrivateOption,
-  RequiredOption,
-} from './base';
+import type { Attribute } from '@strapi/strapi';
 
-export type RichTextAttribute = Attribute<'richtext'> &
+export type RichText = Attribute.OfType<'richtext'> &
   // Options
-  ConfigurableOption &
-  DefaultOption<RichTextValue> &
-  MinMaxLengthOption &
-  PrivateOption &
-  RequiredOption;
+  Attribute.ConfigurableOption &
+  Attribute.DefaultOption<RichTextValue> &
+  Attribute.MinMaxLengthOption &
+  Attribute.PrivateOption &
+  Attribute.RequiredOption;
 
 export type RichTextValue = string;
 
-export type GetRichTextAttributeValue<T extends Attribute> = T extends RichTextAttribute
+export type GetRichTextValue<T extends Attribute.Attribute> = T extends RichText
   ? RichTextValue
   : never;