@strapi/strapi 4.14.0-beta.0 → 4.14.1

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

@@ -1,146 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,90 +0,0 @@
-import type { Attribute, Common, Utils } from '@strapi/strapi';
-
-import type * as Operator from './operators';
-import type * as AttributeUtils from '../attributes';
-import type Params from '../index';
-
-export { Operator };
-
-type IDKey = 'id';
-
-/**
- * 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 IDKey | Attribute.GetKeys<TSchemaUID>
-> = Utils.Expression.MatchFirst<
-  [
-    // Special catch for manually added ID attributes
-    [Utils.Expression.StrictEqual<TAttributeName, IDKey>, Params.Attribute.ID],
-    [
-      Utils.Expression.IsNotNever<TAttributeName>,
-      // Get the filter attribute value for the given attribute
-      AttributeUtils.GetValue<Attribute.Get<TSchemaUID, Exclude<TAttributeName, IDKey>>>
-    ]
-  ],
-  // 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 IDKey | 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>
-            | 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

@@ -1,30 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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>;

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

@@ -1,130 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

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