@strapi/strapi 4.13.0-beta.0 → 4.13.1

package/lib/services/entity-service/types/params/populate.d.ts

@@ -0,0 +1,130 @@
+import type { Attribute, Common, EntityService, Utils } from '@strapi/strapi';
+import type * as Params from './index';
+
+/**
+ * Wildcard notation for populate
+ *
+ * To populate all the root level relations
+ */
+export type WildcardNotation = '*';
+
+/**
+ * Union of all possible string representation for populate
+ *
+ * @example
+ * type A = 'image'; // ✅
+ * type B = 'image,component'; // ✅
+ * type c = '*'; // ✅
+ * type D = 'populatableField'; // ✅
+ * type E = '<random_string>'; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> =
+  | WildcardNotation
+  // Populatable keys
+  | Utils.Guard.Never<Attribute.GetPopulatableKeys<TSchemaUID>, string>
+  // Other string notations
+  // Those are not computed as it would break the TS parser for schemas with lots of populatable attributes
+  | `${string},${string}`
+  | `${string}.${string}`;
+
+/**
+ * Array notation for populate
+ *
+ * @example
+ * type A = ['image']; // ✅
+ * type B = ['image', 'component']; // ✅
+ * type C = ['populatableField']; // ✅
+ * type D = ['<random_string>']; // ❌
+ * type E = ['*']; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Exclude<
+  StringNotation<TSchemaUID>,
+  WildcardNotation
+>[];
+
+type GetPopulatableKeysWithTarget<TSchemaUID extends Common.UID.Schema> = Extract<
+  Attribute.GetPopulatableKeys<TSchemaUID>,
+  Attribute.GetKeysWithTarget<TSchemaUID>
+>;
+
+type GetPopulatableKeysWithoutTarget<TSchemaUID extends Common.UID.Schema> = Exclude<
+  Attribute.GetPopulatableKeys<TSchemaUID>,
+  GetPopulatableKeysWithTarget<TSchemaUID>
+>;
+
+/**
+ * Fragment populate notation for polymorphic attributes
+ */
+export type Fragment<TMaybeTargets extends Common.UID.Schema> = {
+  on?: { [TSchemaUID in TMaybeTargets]?: boolean | NestedParams<TSchemaUID> };
+};
+
+type PopulateClause<
+  TSchemaUID extends Common.UID.Schema,
+  TKeys extends Attribute.GetPopulatableKeys<TSchemaUID>
+> = {
+  [TKey in TKeys]?: boolean | NestedParams<Attribute.GetTarget<TSchemaUID, TKey>>;
+};
+
+/**
+ * Object notation for populate
+ *
+ * @example
+ * type A = { image: true }; // ✅
+ * type B = { image: { fields: ['url', 'provider'] } }; // ✅
+ * type C = { populatableField: { populate: { nestedPopulatableField: true } } }; // ✅
+ * type D = { dynamic_zone: { on: { comp_A: { fields: ['name', 'price_a'] }, comp_B: { fields: ['name', 'price_b'] } } } }; // ✅
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = [
+  GetPopulatableKeysWithTarget<TSchemaUID>,
+  GetPopulatableKeysWithoutTarget<TSchemaUID>
+] extends [
+  infer TKeysWithTarget extends Attribute.GetPopulatableKeys<TSchemaUID>,
+  infer TKeysWithoutTarget extends Attribute.GetPopulatableKeys<TSchemaUID>
+]
+  ? Utils.Expression.If<
+      Utils.Expression.And<
+        Common.AreSchemaRegistriesExtended,
+        // If TSchemaUID === Common.UID.Schema, then ignore it and move to loose types
+        // Note: Currently, this only ignores TSchemaUID when it is equal to Common.UID.Schema, it won't work if Common.UID.(ContentType|Component) is passed as parameter
+        Utils.Expression.DoesNotExtends<Common.UID.Schema, TSchemaUID>
+      >,
+      // Populatable keys with a target
+      | Utils.Expression.If<
+          Utils.Expression.IsNotNever<TKeysWithTarget>,
+          PopulateClause<TSchemaUID, TKeysWithTarget>
+        >
+      // Populatable keys with either zero or multiple target(s)
+      | Utils.Expression.If<
+          Utils.Expression.IsNotNever<TKeysWithoutTarget>,
+          {
+            [TKey in TKeysWithoutTarget]?:
+              | boolean
+              | Fragment<
+                  Utils.Guard.Never<Attribute.GetMorphTargets<TSchemaUID, TKey>, Common.UID.Schema>
+                >
+              // TODO: V5: Remove root-level nested params for morph data structures and only allow fragments
+              | NestedParams<Common.UID.Schema>;
+          }
+        >,
+      // Loose fallback when registries are not extended
+      | { [TKey in string]?: boolean | NestedParams<Common.UID.Schema> }
+      | {
+          [TKey in string]?:
+            | boolean
+            | Fragment<Common.UID.Schema>
+            // TODO: V5: Remove root-level nested params for morph data structures and only allow fragments
+            | NestedParams<Common.UID.Schema>;
+        }
+    >
+  : never;
+
+export type NestedParams<TSchemaUID extends Common.UID.Schema> = EntityService.Params.Pick<
+  TSchemaUID,
+  'fields' | 'filters' | 'populate' | 'sort' | 'plugin' | 'publicationState'
+>;
+
+export type Any<TSchemaUID extends Common.UID.Schema> =
+  | StringNotation<TSchemaUID>
+  | ArrayNotation<TSchemaUID>
+  | ObjectNotation<TSchemaUID>;

package/lib/services/entity-service/types/params/publication-state.d.ts

@@ -0,0 +1,38 @@
+import type { Common, Utils } from '@strapi/strapi';
+
+export type Kind = 'preview' | 'live';
+
+export type IsEnabled<TSchemaUID extends Common.UID.Schema> = Utils.Expression.MatchFirst<
+  [
+    [
+      Common.UID.IsContentType<TSchemaUID>,
+      Utils.Expression.IsTrue<Common.Schemas[TSchemaUID]['options']['draftAndPublish']>
+    ],
+    [
+      // Here, we're manually excluding potential overlap between Component and ContentTypes' UIDs and thus preventing false positives
+      // e.g. api::foo.bar extends a Component UID (`${string}.${string}`) but shouldn't be considered a component
+      Utils.Expression.And<
+        Utils.Expression.Not<Utils.Expression.Extends<TSchemaUID, Common.UID.ContentType>>,
+        Common.UID.IsComponent<TSchemaUID>
+      >,
+      Utils.Expression.False
+    ]
+  ],
+  Utils.Expression.BooleanValue
+>;
+
+export type For<TSchemaUID extends Common.UID.Schema> = IsEnabled<TSchemaUID> extends infer TEnabled
+  ? Utils.Expression.If<
+      Utils.Expression.Or<
+        // If publication state is enabled for the given content type
+        Utils.Expression.IsTrue<TEnabled>,
+        // Or if the content type is not resolved (IsEnabled is BooleanValue)
+        // NOTE: The parameters order is important here ([true/false] extends [boolean] but [boolean] don't extend [true/false])
+        Utils.Expression.Extends<Utils.Expression.BooleanValue, TEnabled>
+      >,
+      // Then add the publicationState param
+      { publicationState?: Kind },
+      // Else, don't do anything
+      {}
+    >
+  : never;

package/lib/services/entity-service/types/params/search.d.ts

@@ -0,0 +1 @@
+export type Q = string;

package/lib/services/entity-service/types/params/sort.d.ts

@@ -0,0 +1,106 @@
+import type { Attribute, Common, Utils } from '@strapi/strapi';
+
+export module OrderKind {
+  export type Asc = 'asc';
+  export type Desc = 'desc';
+
+  export type Any = Asc | Desc;
+}
+
+/**
+ * Single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'description'; // ✅
+ * type C = 'title:asc'; // ❌
+ * type D = 'title,description'; // ❌
+ */
+type SingleAttribute<TSchemaUID extends Common.UID.Schema> =
+  | 'id'
+  | Utils.Guard.Never<string & Attribute.GetNonPopulatableKeys<TSchemaUID>, string>;
+
+/**
+ * Ordered single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ❌
+ * type D = 'title,description'; // ❌
+ */
+type OrderedSingleAttribute<TSchemaUID extends Common.UID.Schema> =
+  `${SingleAttribute<TSchemaUID>}:${OrderKind.Any}`;
+
+/**
+ * Union of all possible string representation for a sort
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description:asc'; // ✅
+ * type E = [42]; // ❌
+ * type F = { title: 'asc' }; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> =
+  | SingleAttribute<TSchemaUID>
+  | OrderedSingleAttribute<TSchemaUID>
+  // TODO: Loose type checking to avoid circular dependencies & infinite recursion
+  | `${string},${string}`;
+
+/**
+ * Array notation for a sort
+ *
+ * @example
+ * type A = ['title:asc', 'description']; // ✅
+ * type B = ['title']; // ✅
+ * type C = ['count', 'title,description:asc']; // ✅
+ * type D = { title: 'asc' }; // ❌
+ * type E = [42]; // ❌
+ * type F = 'title'; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Any<TSchemaUID>[];
+
+/**
+ * Object notation for a sort
+ *
+ * @example
+ * type A = { title: 'asc' }; // ✅
+ * type B = { title: 'asc', description: 'desc' }; // ✅
+ * type C = { title: 'asc', author: { name: 'asc' } }; // ✅
+ * type D = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
+ * type E = ['title']; // ❌
+ * type F = 'title'; // ❌
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
+  // First level sort
+  [key in SingleAttribute<TSchemaUID>]?: OrderKind.Any;
+} & {
+  // Deep sort, only add populatable keys that have a
+  // target (remove dynamic zones and other polymorphic links)
+  [key in Attribute.GetKeysWithTarget<TSchemaUID>]?: ObjectNotation<
+    Attribute.GetTarget<TSchemaUID, key>
+  >;
+};
+
+/**
+ * Represents any notation for a sort (string, array, object)
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description:asc'; // ✅
+ * type E = ['title:asc', 'description']; // ✅
+ * type F = ['title']; // ✅
+ * type G = ['count', 'title,description:asc']; // ✅
+ * type H = { title: 'asc' }; // ✅
+ * type I = { title: 'asc', description: 'desc' }; // ✅
+ * type J = { title: 'asc', author: { name: 'asc' } }; // ✅
+ * type K = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
+ */
+export type Any<TSchemaUID extends Common.UID.Schema> =
+  | StringNotation<TSchemaUID>
+  | ArrayNotation<TSchemaUID>
+  | ObjectNotation<TSchemaUID>;

package/lib/services/entity-service/types/plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Common, Plugin, Utils, Shared } from '@strapi/strapi';
+
+export type GetPluginParams<TSchemaUID extends Common.UID.Schema> = Utils.Guard.OfTypes<
+  [never, undefined],
+  Utils.Object.Values<{
+    [TPluginName in keyof Shared.EntityServicePluginParams]: Shared.EntityServicePluginParams[TPluginName] extends infer TParam
+      ? Utils.Expression.If<Plugin.IsEnabled<TPluginName, TSchemaUID>, TParam>
+      : never;
+  }>,
+  unknown
+>;

package/lib/services/entity-service/types/result.d.ts

@@ -0,0 +1,205 @@
+import type { Attribute, Common, EntityService, Utils } from '@strapi/strapi';
+
+type Pagination = { page: number; pageSize: number; pageCount: number; total: number };
+
+type AnyEntity = { id: EntityService.Params.Attribute.ID } & { [key: string]: any };
+
+export type Result<
+  TSchemaUID extends Common.UID.Schema,
+  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
+> = Utils.Expression.If<
+  Common.AreSchemaRegistriesExtended,
+  GetValues<
+    TSchemaUID,
+    Utils.Guard.Never<
+      ExtractFields<TSchemaUID, TParams['fields']>,
+      Attribute.GetNonPopulatableKeys<TSchemaUID>
+    >,
+    ExtractPopulate<TSchemaUID, TParams['populate']>
+  >,
+  AnyEntity
+>;
+
+export type Entity<
+  TSchemaUID extends Common.UID.Schema,
+  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
+> = Utils.Expression.If<
+  Common.AreSchemaRegistriesExtended,
+  GetValues<
+    TSchemaUID,
+    Utils.Guard.Never<
+      ExtractFields<TSchemaUID, TParams['fields']>,
+      Attribute.GetNonPopulatableKeys<TSchemaUID>
+    >,
+    Utils.Guard.Never<
+      ExtractPopulate<TSchemaUID, TParams['populate']>,
+      Attribute.GetPopulatableKeys<TSchemaUID>
+    >
+  >,
+  AnyEntity
+>;
+
+export type PartialEntity<
+  TSchemaUID extends Common.UID.Schema,
+  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
+> = Partial<Entity<TSchemaUID, TParams>>;
+
+export type PaginatedResult<
+  TSchemaUID extends Common.UID.Schema,
+  TParams extends EntityService.Params.Pick<TSchemaUID, 'fields' | 'populate'> = never
+> = {
+  results: Entity<TSchemaUID, TParams>[];
+  pagination: Pagination;
+};
+
+/**
+ * Attribute.GetValues override with extended values
+ *
+ * TODO: Make it recursive for populatable fields
+ */
+export type GetValues<
+  TSchemaUID extends Common.UID.Schema,
+  TFields extends Attribute.GetKeys<TSchemaUID>,
+  TPopulate extends Attribute.GetKeys<TSchemaUID>
+> = Utils.Expression.If<
+  Common.AreSchemaRegistriesExtended,
+  Utils.Guard.Never<TFields | TPopulate, Attribute.GetKeys<TSchemaUID>> extends infer TKeys
+    ? Attribute.GetValues<TSchemaUID, TKeys>
+    : never,
+  AnyEntity
+>;
+
+type ExtractFields<
+  TSchemaUID extends Common.UID.Schema,
+  TFields extends EntityService.Params.Fields.Any<TSchemaUID>
+> = Utils.Expression.MatchFirst<
+  [
+    // No fields provided
+    [
+      Utils.Expression.Or<
+        Utils.Expression.StrictEqual<TFields, EntityService.Params.Fields.Any<TSchemaUID>>,
+        Utils.Expression.IsNever<TFields>
+      >,
+      never
+    ],
+    // string
+    [
+      Utils.Expression.Extends<TFields, EntityService.Params.Fields.StringNotation<TSchemaUID>>,
+      ParseStringFields<
+        TSchemaUID,
+        Utils.Cast<TFields, EntityService.Params.Fields.StringNotation<TSchemaUID>>
+      >
+    ],
+    // string array
+    [
+      Utils.Expression.Extends<TFields, EntityService.Params.Fields.ArrayNotation<TSchemaUID>>,
+      ParseStringFields<
+        TSchemaUID,
+        Utils.Cast<
+          Utils.Array.Values<
+            Utils.Cast<TFields, EntityService.Params.Fields.ArrayNotation<TSchemaUID>>
+          >,
+          EntityService.Params.Fields.StringNotation<TSchemaUID>
+        >
+      >
+    ]
+  ]
+>;
+
+type ParseStringFields<
+  TSchemaUID extends Common.UID.Schema,
+  TFields extends EntityService.Params.Fields.StringNotation<TSchemaUID>
+> = Utils.Expression.MatchFirst<
+  [
+    [
+      Utils.Expression.StrictEqual<TFields, EntityService.Params.Fields.WildcardNotation>,
+      Attribute.GetNonPopulatableKeys<TSchemaUID>
+    ],
+    [
+      Utils.Expression.Extends<TFields, EntityService.Params.Fields.SingleAttribute<TSchemaUID>>,
+      TFields
+    ],
+    [
+      Utils.Expression.Extends<TFields, `${string},${string}`>,
+      Utils.Array.Values<Utils.String.Split<Utils.Cast<TFields, string>, ','>>
+    ]
+  ]
+>;
+
+type ExtractPopulate<
+  TSchemaUID extends Common.UID.Schema,
+  TPopulate extends EntityService.Params.Populate.Any<TSchemaUID>
+> = Utils.Expression.MatchFirst<
+  [
+    // No populate provided
+    [
+      Utils.Expression.Or<
+        Utils.Expression.StrictEqual<TPopulate, EntityService.Params.Populate.Any<TSchemaUID>>,
+        Utils.Expression.IsNever<TPopulate>
+      >,
+      never
+    ],
+    // string notation
+    [
+      Utils.Expression.Extends<TPopulate, EntityService.Params.Populate.StringNotation<TSchemaUID>>,
+      ParseStringPopulate<
+        TSchemaUID,
+        Utils.Cast<TPopulate, EntityService.Params.Populate.StringNotation<TSchemaUID>>
+      >
+    ],
+    // Array notation
+    [
+      Utils.Expression.Extends<TPopulate, EntityService.Params.Populate.ArrayNotation<TSchemaUID>>,
+      ParseStringPopulate<
+        TSchemaUID,
+        Utils.Cast<
+          Utils.Array.Values<
+            Utils.Cast<TPopulate, EntityService.Params.Populate.ArrayNotation<TSchemaUID>>
+          >,
+          EntityService.Params.Populate.StringNotation<TSchemaUID>
+        >
+      >
+    ],
+    // object notation
+    [
+      Utils.Expression.Extends<TPopulate, EntityService.Params.Populate.ObjectNotation<TSchemaUID>>,
+      ParseStringPopulate<
+        TSchemaUID,
+        // TODO: Handle relations set to false in object notation
+        Utils.Cast<keyof TPopulate, EntityService.Params.Populate.StringNotation<TSchemaUID>>
+      >
+    ]
+  ]
+>;
+
+type ParsePopulateDotNotation<
+  TSchemaUID extends Common.UID.Schema,
+  TPopulate extends EntityService.Params.Populate.StringNotation<TSchemaUID>
+> = Utils.String.Split<Utils.Cast<TPopulate, string>, '.'>[0];
+
+type ParseStringPopulate<
+  TSchemaUID extends Common.UID.Schema,
+  TPopulate extends EntityService.Params.Populate.StringNotation<TSchemaUID>
+> = Utils.Expression.MatchFirst<
+  [
+    [
+      Utils.Expression.StrictEqual<EntityService.Params.Populate.WildcardNotation, TPopulate>,
+      Attribute.GetPopulatableKeys<TSchemaUID>
+    ],
+    [
+      Utils.Expression.Extends<TPopulate, `${string},${string}`>,
+      ParsePopulateDotNotation<
+        TSchemaUID,
+        Utils.Cast<
+          Utils.Array.Values<Utils.String.Split<Utils.Cast<TPopulate, string>, ','>>,
+          EntityService.Params.Populate.StringNotation<TSchemaUID>
+        >
+      >
+    ],
+    [
+      Utils.Expression.Extends<TPopulate, `${string}.${string}`>,
+      ParsePopulateDotNotation<TSchemaUID, TPopulate>
+    ]
+  ],
+  TPopulate
+>;

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

@@ -2,7 +2,7 @@
  * Strapi custom scalar types
  */
 
-import { Attribute, Common } from '@strapi/strapi';
+import type { Attribute, Common } from '@strapi/strapi';
 
 /**
  * Setters for the attributes options
@@ -58,17 +58,20 @@ export type Any =
   | Attribute.JSON
   | Attribute.Media<Attribute.MediaKind | undefined, boolean>
   | Attribute.Password
-  | (
-      | Attribute.Relation<
-          Common.UID.Schema,
-          Attribute.RelationKind.BiDirectional,
-          Common.UID.Schema
-        >
-      | Attribute.Relation<Common.UID.Schema, Attribute.RelationKind.UniDirectional>
-    )
+  | Attribute.Relation<Common.UID.Schema, Attribute.RelationKind.Any, Common.UID.Schema>
   | Attribute.RichText
   | Attribute.String
   | Attribute.Text
   | Attribute.Time
   | Attribute.Timestamp
-  | Attribute.UID<Common.UID.Schema | undefined>;
+  | Attribute.UID<Common.UID.Schema>;
+
+export type PopulatableKind = Extract<
+  Attribute.Kind,
+  'relation' | 'component' | 'dynamiczone' | 'media'
+>;
+
+export type NonPopulatableKind = Exclude<
+  Attribute.Kind,
+  'relation' | 'component' | 'dynamiczone' | 'media'
+>;

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

@@ -31,3 +31,6 @@ export type GetComponentValue<TAttribute extends Attribute.Attribute> =
   TAttribute extends Component<infer TComponentUID, infer TRepeatable>
     ? ComponentValue<TComponentUID, TRepeatable>
     : never;
+
+export type GetComponentTarget<TAttribute extends Attribute.Attribute> =
+  TAttribute extends Component<infer TComponentUID, infer _TRepeatable> ? TComponentUID : never;

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

@@ -8,7 +8,8 @@ export type DateTime = Attribute.OfType<'datetime'> &
   Attribute.RequiredOption &
   Attribute.UniqueOption;
 
-export type DateTimeValue = string;
+// TODO: Use string templates for date formats
+export type DateTimeValue = globalThis.Date | string;
 
 export type GetDateTimeValue<T extends Attribute.Attribute> = T extends DateTime
   ? DateTimeValue

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

@@ -1,21 +1,21 @@
 import type { Utils, Attribute, Common } from '@strapi/strapi';
 
-export interface DynamicZoneProperties<TComponentsUIDs extends Common.UID.Component[]> {
-  components: TComponentsUIDs;
+export interface DynamicZoneProperties<TComponentsUID extends Common.UID.Component[]> {
+  components: TComponentsUID;
 }
 
-export type DynamicZone<TComponentsUIDs extends Common.UID.Component[] = Common.UID.Component[]> =
+export type DynamicZone<TComponentsUID extends Common.UID.Component[] = Common.UID.Component[]> =
   Attribute.OfType<'dynamiczone'> &
     // Properties
-    DynamicZoneProperties<TComponentsUIDs> &
+    DynamicZoneProperties<TComponentsUID> &
     // Options
     Attribute.ConfigurableOption &
     Attribute.MinMaxOption &
     Attribute.RequiredOption;
 
-type DynamicZoneValue<TComponentsUIDs extends Common.UID.Component[]> = Array<
+type DynamicZoneValue<TComponentsUID extends Common.UID.Component[]> = Array<
   // Extract tuple values to a component uid union type
-  Utils.Array.Values<TComponentsUIDs> extends infer TComponentUID
+  Utils.Array.Values<TComponentsUID> extends infer TComponentUID
     ? TComponentUID extends Common.UID.Component
       ? Attribute.GetValues<TComponentUID> & { __component: TComponentUID }
       : never
@@ -23,4 +23,7 @@ type DynamicZoneValue<TComponentsUIDs extends Common.UID.Component[]> = Array<
 >;
 
 export type GetDynamicZoneValue<TAttribute extends Attribute.Attribute> =
-  TAttribute extends DynamicZone<infer TComponentsUIDs> ? DynamicZoneValue<TComponentsUIDs> : never;
+  TAttribute extends DynamicZone<infer TComponentsUID> ? DynamicZoneValue<TComponentsUID> : never;
+
+export type GetDynamicZoneTargets<TAttribute extends Attribute.Attribute> =
+  TAttribute extends DynamicZone<infer TComponentsUID> ? Utils.Array.Values<TComponentsUID> : never;

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

@@ -1,5 +1,6 @@
 import type { Attribute, Utils } from '@strapi/strapi';
 
+export type MediaTarget = 'plugin::upload.file';
 export type MediaKind = 'images' | 'videos' | 'files' | 'audios';
 
 export interface MediaProperties<
@@ -32,3 +33,10 @@ export type GetMediaValue<TAttribute extends Attribute.Attribute> = TAttribute e
 >
   ? MediaValue<TMultiple>
   : never;
+
+export type GetMediaTarget<TAttribute extends Attribute.Attribute> = TAttribute extends Media<
+  infer _TKind,
+  infer _TMultiple
+>
+  ? MediaTarget
+  : never;