@strapi/strapi 4.13.0-beta.0 → 4.13.0

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

@@ -0,0 +1,228 @@
+import type { Attribute, Common, Utils } from '@strapi/strapi';
+import type { PartialEntity, Entity, Result, PaginatedResult } from './result';
+
+import type * as Params from './params';
+
+// TODO: Move params to @strapi/utils (related to convert-query-params)
+export * as Params from './params';
+
+export * from './result';
+export * from './plugin';
+
+type WrapAction = Omit<keyof EntityService, 'wrapParams' | 'wrapResult' | 'emitEvent'>;
+
+export interface EntityService {
+  wrapParams<
+    TResult = unknown,
+    TContentTypeUID extends Common.UID.ContentType = Common.UID.ContentType,
+    TParams extends object = object
+  >(
+    params?: TParams,
+    options?: { uid: TContentTypeUID; action: WrapAction }
+  ): Promise<TResult> | TResult;
+
+  wrapResult<
+    TResult = unknown,
+    TContentTypeUID extends Common.UID.ContentType = Common.UID.ContentType
+  >(
+    result: unknown,
+    options?: { uid: TContentTypeUID; action: WrapAction }
+  ): Promise<TResult> | TResult;
+
+  emitEvent<TContentTypeUID extends Common.UID.ContentType>(
+    uid: TContentTypeUID,
+    event: string,
+    entity: Entity<TContentTypeUID>
+  ): Promise<void>;
+  // TODO: Split in 2 different signatures for both single types & collection types
+  findMany<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<
+      TContentTypeUID,
+      | 'fields'
+      | 'filters'
+      | '_q'
+      | 'pagination:offset'
+      | 'sort'
+      | 'populate'
+      | 'publicationState'
+      | 'plugin'
+    >
+  >(
+    uid: TContentTypeUID,
+    params?: TParams
+  ): Utils.Expression.MatchFirst<
+    [
+      [Common.UID.IsCollectionType<TContentTypeUID>, Promise<Result<TContentTypeUID, TParams>[]>],
+      [Common.UID.IsSingleType<TContentTypeUID>, Promise<Result<TContentTypeUID, TParams> | null>]
+    ],
+    Promise<(Result<TContentTypeUID, TParams> | null) | Result<TContentTypeUID, TParams>[]>
+  >;
+
+  findOne<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<TContentTypeUID, 'fields' | 'populate'>
+  >(
+    uid: TContentTypeUID,
+    entityId: Params.Attribute.ID,
+    params?: TParams
+  ): Promise<Result<TContentTypeUID, TParams> | null>;
+
+  delete<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<TContentTypeUID, 'fields' | 'populate'>
+  >(
+    uid: TContentTypeUID,
+    entityId: Params.Attribute.ID,
+    params?: TParams
+  ): Promise<Result<TContentTypeUID, TParams> | null>;
+
+  create<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<TContentTypeUID, 'data' | 'files' | 'fields' | 'populate'>
+  >(
+    uid: TContentTypeUID,
+    params?: TParams
+  ): Promise<Result<TContentTypeUID, TParams>>;
+
+  update<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<TContentTypeUID, 'data:partial' | 'files' | 'fields' | 'populate'>
+  >(
+    uid: TContentTypeUID,
+    entityId: Params.Attribute.ID,
+    params?: TParams
+  ): Promise<Result<TContentTypeUID, TParams> | null>;
+
+  findPage<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<
+      TContentTypeUID,
+      | 'fields'
+      | 'populate'
+      | 'pagination'
+      | 'sort'
+      | 'filters'
+      | '_q'
+      | 'publicationState'
+      | 'plugin'
+    >
+  >(
+    uid: TContentTypeUID,
+    params?: TParams
+  ): Promise<PaginatedResult<TContentTypeUID, TParams>>;
+
+  clone<
+    TContentTypeUID extends Common.UID.ContentType,
+    TParams extends Params.Pick<TContentTypeUID, 'data' | 'files' | 'fields' | 'populate'>
+  >(
+    uid: TContentTypeUID,
+    cloneId: Params.Attribute.ID,
+    params?: TParams
+  ): Promise<Result<TContentTypeUID, TParams> | null>;
+
+  /**
+   * @deprecated
+   */
+  deleteMany<TContentTypeUID extends Common.UID.ContentType>(
+    uid: TContentTypeUID,
+    params: Params.Pick<TContentTypeUID, 'filters' | '_q'>
+  ): Promise<{ count: number }>;
+
+  /**
+   * TODO: seems the same as findMany, it's not returning count by default
+   * @deprecated
+   */
+  findWithRelationCounts<
+    TContentTypeUID extends Common.UID.Schema,
+    TParams extends Params.Pick<
+      TContentTypeUID,
+      | 'fields'
+      | 'filters'
+      | '_q'
+      | 'pagination:offset'
+      | 'sort'
+      | 'populate'
+      | 'publicationState'
+      | 'plugin'
+    >
+  >(
+    uid: TContentTypeUID,
+    params?: TParams
+  ): Promise<Result<TContentTypeUID, TParams>[]>;
+
+  /**
+   * @deprecated
+   */
+  findWithRelationCountsPage<
+    TContentTypeUID extends Common.UID.Schema,
+    TParams extends Params.Pick<
+      TContentTypeUID,
+      | 'fields'
+      | 'filters'
+      | '_q'
+      | 'pagination'
+      | 'sort'
+      | 'populate'
+      | 'publicationState'
+      | 'plugin'
+    >
+  >(
+    uid: TContentTypeUID,
+    params?: TParams
+  ): Promise<PaginatedResult<TContentTypeUID, TParams>>;
+
+  count<TContentTypeUID extends Common.UID.ContentType>(
+    uid: TContentTypeUID,
+    params?: Params.Pick<TContentTypeUID, 'filters' | '_q'>
+  ): Promise<number>;
+
+  /**
+   * TODO: Considering making this API public include providing a valid return type
+   * @internal
+   */
+  load<
+    TContentTypeUID extends Common.UID.ContentType,
+    TField extends Attribute.GetPopulatableKeys<TContentTypeUID>
+  >(
+    uid: TContentTypeUID,
+    entity: PartialEntity<TContentTypeUID>,
+    field: Utils.Guard.Never<TField, string>,
+    params?: GetPopulatableFieldParams<TContentTypeUID, TField>
+  ): Promise<any>;
+
+  /**
+   * TODO: Considering making this API public include providing a valid return type
+   * @internal
+   */
+  loadPages<
+    TContentTypeUID extends Common.UID.ContentType,
+    TField extends Attribute.GetPopulatableKeys<TContentTypeUID>
+  >(
+    uid: TContentTypeUID,
+    entity: PartialEntity<TContentTypeUID>,
+    field: Utils.Guard.Never<TField, string>,
+    params?: GetPopulatableFieldParams<TContentTypeUID, TField>,
+    pagination?: Params.Pagination.Any
+  ): Promise<any>;
+}
+
+type GetPopulatableFieldParams<
+  TContentTypeUID extends Common.UID.ContentType,
+  TField extends Attribute.GetPopulatableKeys<TContentTypeUID>
+> = Utils.Expression.MatchFirst<
+  [
+    [
+      Attribute.HasTarget<TContentTypeUID, TField>,
+      Params.Populate.NestedParams<Attribute.GetTarget<TContentTypeUID, TField>>
+    ],
+    [
+      Attribute.HasMorphTargets<TContentTypeUID, TField>,
+      (
+        | Params.Populate.Fragment<Attribute.GetMorphTargets<TContentTypeUID, TField>>
+        | Params.Populate.NestedParams<Common.UID.Schema>
+      )
+    ]
+  ],
+  Params.Populate.Fragment<Common.UID.Schema> | Params.Populate.NestedParams<Common.UID.Schema>
+>;

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

@@ -0,0 +1,146 @@
+import type { Attribute, Common, Utils } from '@strapi/strapi';
+
+export type NonFilterableKind = Extract<Attribute.Kind, 'password' | 'dynamiczone'>;
+export type FilterableKind = Exclude<Attribute.Kind, NonFilterableKind>;
+
+export type GetNonFilterableKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysBy<
+  Attribute.GetAll<TSchemaUID>,
+  Attribute.OfType<NonFilterableKind>
+>;
+
+export type GetScalarKeys<TSchemaUID extends Common.UID.Schema> = Exclude<
+  Attribute.GetKeysByType<TSchemaUID, Attribute.NonPopulatableKind>,
+  GetNonFilterableKeys<TSchemaUID>
+>;
+
+export type GetNestedKeys<TSchemaUID extends Common.UID.Schema> = Exclude<
+  Attribute.GetKeysWithTarget<TSchemaUID>,
+  GetNonFilterableKeys<TSchemaUID>
+>;
+
+export type ID = `${number}` | number;
+
+export type BooleanValue = boolean | 'true' | 'false' | 't' | 'f' | '1' | '0' | 1 | 0;
+
+export type NumberValue = string | number;
+
+export type DateValue = Attribute.DateValue | number;
+
+export type TimeValue = Attribute.TimeValue | number;
+
+export type DateTimeValue = Attribute.DateTimeValue | number;
+
+export type TimeStampValue = Attribute.TimestampValue;
+
+/**
+ * List of possible values for the scalar attributes
+ * Uses the local GetValue to benefit from the values' overrides
+ */
+export type ScalarValues = GetValue<
+  | Attribute.BigInteger
+  | Attribute.Boolean
+  | Attribute.DateTime
+  | Attribute.Date
+  | Attribute.Decimal
+  | Attribute.Email
+  | Attribute.Enumeration<string[]>
+  | Attribute.Float
+  | Attribute.Integer
+  | Attribute.JSON
+  // /!\  Password attributes are NOT filterable and should NOT be part of this union type.
+  //      The member below has been commented on purpose to avoid adding it back without noticing.
+  // | Attribute.Password
+  | Attribute.RichText
+  | Attribute.String
+  | Attribute.Text
+  | Attribute.Time
+  | Attribute.Timestamp
+  | Attribute.UID<Common.UID.Schema | undefined>
+>;
+
+/**
+ * Attribute.GetValues override with extended values
+ */
+export type GetValues<TSchemaUID extends Common.UID.Schema> = OmitRelationWithoutTarget<
+  TSchemaUID,
+  {
+    [TKey in Attribute.GetOptionalKeys<TSchemaUID>]?: GetValue<Attribute.Get<TSchemaUID, TKey>>;
+  } & {
+    [TKey in Attribute.GetRequiredKeys<TSchemaUID>]-?: GetValue<Attribute.Get<TSchemaUID, TKey>>;
+  }
+>;
+
+export type OmitRelationWithoutTarget<TSchemaUID extends Common.UID.Schema, TValue> = Omit<
+  TValue,
+  Exclude<Attribute.GetKeysByType<TSchemaUID, 'relation'>, Attribute.GetKeysWithTarget<TSchemaUID>>
+>;
+
+/**
+ * Attribute.GetValue override with extended values
+ *
+ * Fallback to unknown if never is found
+ */
+export type GetValue<TAttribute extends Attribute.Attribute> = Utils.Expression.If<
+  Utils.Expression.IsNotNever<TAttribute>,
+  Utils.Expression.MatchFirst<
+    [
+      // Relation
+      [
+        Utils.Expression.Extends<TAttribute, Attribute.OfType<'relation'>>,
+        TAttribute extends Attribute.Relation<infer _TOrigin, infer TRelationKind, infer TTarget>
+          ? Utils.Expression.If<
+              Utils.Expression.IsNotNever<TTarget>,
+              Attribute.RelationPluralityModifier<TRelationKind, ID>
+            >
+          : never
+      ],
+      // DynamicZone
+      [
+        Utils.Expression.Extends<TAttribute, Attribute.OfType<'dynamiczone'>>,
+        TAttribute extends Attribute.DynamicZone<infer TComponentsUIDs>
+          ? Array<
+              // Extract tuple values to a component uid union type
+              Utils.Array.Values<TComponentsUIDs> extends infer TComponentUID
+                ? TComponentUID extends Common.UID.Component
+                  ? GetValues<TComponentUID> & { __component: TComponentUID }
+                  : never
+                : never
+            >
+          : never
+      ],
+      // Component
+      [
+        Utils.Expression.Extends<TAttribute, Attribute.OfType<'component'>>,
+        TAttribute extends Attribute.Component<infer TComponentUID, infer TRepeatable>
+          ? TComponentUID extends Common.UID.Component
+            ? GetValues<TComponentUID> extends infer TValues
+              ? Utils.Expression.If<TRepeatable, TValues[], TValues>
+              : never
+            : never
+          : never
+      ],
+      // Boolean
+      [Utils.Expression.Extends<TAttribute, Attribute.Boolean>, BooleanValue],
+      // Number
+      [
+        Utils.Expression.Extends<
+          TAttribute,
+          Attribute.Integer | Attribute.BigInteger | Attribute.Float | Attribute.Decimal
+        >,
+        NumberValue
+      ],
+      // Date / Time
+      [Utils.Expression.Extends<TAttribute, Attribute.Time>, TimeValue],
+      [Utils.Expression.Extends<TAttribute, Attribute.Date>, DateValue],
+      [
+        Utils.Expression.Extends<TAttribute, Attribute.Timestamp | Attribute.DateTime>,
+        DateTimeValue
+      ],
+      // Fallback
+      // If none of the above attribute type, fallback to the original Attribute.GetValue (while making sure it's an attribute)
+      [Utils.Expression.True, Attribute.GetValue<TAttribute, unknown>]
+    ],
+    unknown
+  >,
+  unknown
+>;

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

@@ -0,0 +1,4 @@
+import { Common } from '@strapi/strapi';
+import * as AttributeUtils from './attributes';
+
+export type Input<TSchemaUID extends Common.UID.Schema> = AttributeUtils.GetValues<TSchemaUID>;

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

@@ -0,0 +1,74 @@
+import type { Attribute, Common, Utils } from '@strapi/strapi';
+
+/**
+ * Wildcard notation for the fields.
+ *
+ * When used, it represents every non-populatable field from the given schema
+ */
+export type WildcardNotation = '*';
+
+/**
+ * Single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'description'; // ✅
+ * type C = 'populatableField'; // ❌
+ * type D = '<random_string>'; // ❌
+ */
+export type SingleAttribute<TSchemaUID extends Common.UID.Schema> =
+  | 'id'
+  | Utils.Guard.Never<Attribute.GetNonPopulatableKeys<TSchemaUID>, string>;
+
+/**
+ * Union of all possible string representation for fields
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'title,description'; // ✅
+ * type C = 'id'; // ✅
+ * type D = '*'; // ✅
+ * type E = 'populatableField'; // ❌
+ * type F = '<random_string>'; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> =
+  | WildcardNotation
+  | SingleAttribute<TSchemaUID>
+  // TODO: Loose type checking to avoid circular dependencies & infinite recursion
+  | `${string},${string}`;
+
+/**
+ * Array notation for fields
+ *
+ * @example
+ * type A = ['title']; // ✅
+ * type B = ['title', 'description']; // ✅
+ * type C = ['id']; // ✅
+ * type E = ['*']; // ❌
+ * type F = ['populatableField']; // ❌
+ * type G = ['<random_string>']; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Exclude<
+  StringNotation<TSchemaUID>,
+  WildcardNotation
+>[];
+
+/**
+ * Represents any notation for a sort (string, array, object)
+ *
+ * @example
+ * type A = '*'; // ✅
+ * type B = 'id'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description'; // ✅
+ * type E = ['title', 'description']; // ✅
+ * type F = [id, 'title,description']; // ✅
+ * type G = ['*']; // ❌
+ * type H = ['populatableField']; // ❌
+ * type I = ['<random_string>']; // ❌
+ * type J = 'populatableField'; // ❌
+ * type K = '<random_string>'; // ❌
+ */
+export type Any<TSchemaUID extends Common.UID.Schema> =
+  | StringNotation<TSchemaUID>
+  | ArrayNotation<TSchemaUID>;

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

@@ -0,0 +1,75 @@
+import type { Attribute, Common, Utils } from '@strapi/strapi';
+
+import type * as Operator from './operators';
+import type * as AttributeUtils from '../attributes';
+
+export { Operator };
+
+/**
+ * Filter representation for nested attributes
+ */
+type NestedAttributeCondition<
+  TSchemaUID extends Common.UID.Schema,
+  TAttributeName extends Attribute.GetKeys<TSchemaUID>
+> = ObjectNotation<
+  Utils.Guard.Never<Attribute.GetTarget<TSchemaUID, TAttributeName>, Common.UID.Schema>
+>;
+
+/**
+ * Filter representation for scalar attributes
+ */
+type AttributeCondition<
+  TSchemaUID extends Common.UID.Schema,
+  TAttributeName extends Attribute.GetKeys<TSchemaUID>
+> = Utils.Expression.If<
+  Utils.Expression.IsNotNever<TAttributeName>,
+  // Get the filter attribute value for the given attribute
+  AttributeUtils.GetValue<Attribute.Get<TSchemaUID, TAttributeName>>,
+  // Fallback to the list of all possible scalar attributes' value if the attribute is not valid (never)
+  AttributeUtils.ScalarValues
+> extends infer TAttributeValue
+  ?
+      | TAttributeValue // Implicit $eq operator
+      | ({
+          [TIter in Operator.BooleanValue]?: boolean;
+        } & {
+          [TIter in Operator.DynamicValue]?: TAttributeValue;
+        } & {
+          [TIter in Operator.DynamicArrayValue]?: TAttributeValue[];
+        } & {
+          [TIter in Operator.DynamicBoundValue]?: [TAttributeValue, TAttributeValue];
+        } & {
+          [TIter in Operator.Logical]?: AttributeCondition<TSchemaUID, TAttributeName>;
+        } & {
+          [TIter in Operator.Group]?: AttributeCondition<TSchemaUID, TAttributeName>[];
+        })
+  : never;
+
+/**
+ * Tree representation of a Strapi filter for a given schema UID
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
+  [TIter in Operator.Group]?: ObjectNotation<TSchemaUID>[];
+} & {
+  [TIter in Operator.Logical]?: ObjectNotation<TSchemaUID>;
+} & ([AttributeUtils.GetScalarKeys<TSchemaUID>, AttributeUtils.GetNestedKeys<TSchemaUID>] extends [
+    infer TScalarKeys extends AttributeUtils.GetScalarKeys<TSchemaUID>,
+    infer TNestedKeys extends AttributeUtils.GetNestedKeys<TSchemaUID>
+  ]
+    ? // If both the scalar and nested keys are resolved, then create a strongly
+      // typed filter object, else create a loose generic abstraction.
+      Utils.Expression.If<
+        Utils.Expression.And<
+          Utils.Expression.IsNotNever<TScalarKeys>,
+          Utils.Expression.IsNotNever<TNestedKeys>
+        >,
+        // Strongly typed representation of the filter object tree
+        | { [TIter in TScalarKeys]?: AttributeCondition<TSchemaUID, TIter> }
+        | { [TIter in TNestedKeys]?: NestedAttributeCondition<TSchemaUID, TIter> },
+        // Generic representation of the filter object tree in case we don't have access to the attributes' list
+        | { [TKey in string]?: AttributeCondition<TSchemaUID, never> }
+        | { [TKey in string]?: NestedAttributeCondition<TSchemaUID, never> }
+      >
+    : never);
+
+export type Any<TSchemaUID extends Common.UID.Schema> = ObjectNotation<TSchemaUID>;

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

@@ -0,0 +1,30 @@
+export type Array = '$in' | '$notIn' | '$between';
+
+export type Group = '$and' | '$or';
+
+export type Logical = '$not';
+
+export type BooleanValue = '$null' | '$notNull';
+
+export type DynamicValue =
+  | '$eq'
+  | '$eqi'
+  | '$ne'
+  | '$gt'
+  | '$gte'
+  | '$lt'
+  | '$lte'
+  | '$startsWith'
+  | '$endsWith'
+  | '$startsWithi'
+  | '$endsWithi'
+  | '$contains'
+  | '$notContains'
+  | '$containsi'
+  | '$notContainsi';
+
+export type DynamicArrayValue = '$in' | '$notIn';
+
+export type DynamicBoundValue = '$between';
+
+export type Where = BooleanValue | DynamicValue | DynamicArrayValue | DynamicBoundValue;

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

@@ -0,0 +1,79 @@
+import type { Common, EntityService, Utils } from '@strapi/strapi';
+// Params
+import type * as Sort from './sort';
+import type * as Pagination from './pagination';
+import type * as Fields from './fields';
+import type * as Filters from './filters';
+import type * as Populate from './populate';
+import type * as PublicationState from './publication-state';
+import type * as Data from './data';
+import type * as Search from './search';
+
+// Utils
+import type * as Attribute from './attributes';
+
+export type Pick<
+  TSchemaUID extends Common.UID.Schema,
+  TKind extends Kind
+> = Utils.Expression.MatchAllIntersect<
+  [
+    // Sort
+    [HasMember<TKind, 'sort'>, { sort?: Sort.Any<TSchemaUID> }],
+    [HasMember<TKind, 'sort:string'>, { sort?: Sort.StringNotation<TSchemaUID> }],
+    [HasMember<TKind, 'sort:array'>, { sort?: Sort.ArrayNotation<TSchemaUID> }],
+    [HasMember<TKind, 'sort:object'>, { sort?: Sort.ObjectNotation<TSchemaUID> }],
+    // Fields
+    [HasMember<TKind, 'fields'>, { fields?: Fields.Any<TSchemaUID> }],
+    [HasMember<TKind, 'fields:string'>, { fields?: Fields.StringNotation<TSchemaUID> }],
+    [HasMember<TKind, 'fields:array'>, { fields?: Fields.ArrayNotation<TSchemaUID> }],
+    // Filters
+    [HasMember<TKind, 'filters'>, { filters?: Filters.Any<TSchemaUID> }],
+    // Populate
+    [HasMember<TKind, 'populate'>, { populate?: Populate.Any<TSchemaUID> }],
+    [HasMember<TKind, 'populate:string'>, { populate?: Populate.StringNotation<TSchemaUID> }],
+    [HasMember<TKind, 'populate:array'>, { populate?: Populate.ArrayNotation<TSchemaUID> }],
+    [HasMember<TKind, 'populate:object'>, { populate?: Populate.ObjectNotation<TSchemaUID> }],
+    // Pagination
+    [HasMember<TKind, 'pagination'>, Pagination.Any],
+    [HasMember<TKind, 'pagination:offset'>, Pagination.OffsetNotation],
+    [HasMember<TKind, 'pagination:page'>, Pagination.PageNotation],
+    // Publication State
+    [HasMember<TKind, 'publicationState'>, PublicationState.For<TSchemaUID>],
+    // Plugin
+    [HasMember<TKind, 'plugin'>, EntityService.GetPluginParams<TSchemaUID>],
+    // Data
+    [HasMember<TKind, 'data'>, { data?: Data.Input<TSchemaUID> }],
+    [HasMember<TKind, 'data:partial'>, { data?: Partial<Data.Input<TSchemaUID>> }],
+    // Files
+    [HasMember<TKind, 'files'>, { files?: unknown }], // TODO
+    // Search
+    [HasMember<TKind, '_q'>, { _q?: Search.Q }]
+  ]
+>;
+
+export type Kind =
+  | 'sort'
+  | 'sort:string'
+  | 'sort:array'
+  | 'sort:object'
+  | 'fields'
+  | 'fields:string'
+  | 'fields:array'
+  | 'filters'
+  | 'populate'
+  | 'populate:string'
+  | 'populate:array'
+  | 'populate:object'
+  | 'pagination'
+  | 'pagination:offset'
+  | 'pagination:page'
+  | 'publicationState'
+  | 'plugin'
+  | 'data'
+  | 'data:partial'
+  | 'files'
+  | '_q';
+
+type HasMember<TValue extends Kind, TTest extends Kind> = Utils.Expression.Extends<TTest, TValue>;
+
+export type { Sort, Pagination, Fields, Filters, Populate, PublicationState, Data, Attribute };

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

@@ -0,0 +1,13 @@
+import type { Utils } from '@strapi/strapi';
+
+export type PageNotation = {
+  page?: number;
+  pageSize?: number;
+};
+
+export type OffsetNotation = {
+  start?: number;
+  limit?: number;
+};
+
+export type Any = Utils.XOR<PageNotation, OffsetNotation>;