@strapi/strapi 4.13.0-beta.0 → 4.13.0

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

@@ -5,53 +5,79 @@ export type Relation<
   // 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,
+  _TOrigin extends Common.UID.Schema = Common.UID.Schema,
   TRelationKind extends RelationKind.Any = RelationKind.Any,
   TTarget extends Common.UID.Schema = never
 > = Attribute.OfType<'relation'> &
   // Properties
-  RelationProperties<TOrigin, TRelationKind, TTarget> &
+  Utils.Guard.Never<RelationProperties<TRelationKind, TTarget>, AllRelationProperties<TTarget>> &
   // Options
   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<
+      BiDirectionalProperties<Utils.Cast<TRelationKind, RelationKind.BiDirectional>, TTarget>
+    ],
+    [
+      Utils.Expression.Extends<TRelationKind, RelationKind.XWay>,
+      XWayProperties<Utils.Cast<TRelationKind, RelationKind.XWay>, TTarget>
+    ],
+    [
       Utils.Expression.Extends<TRelationKind, RelationKind.MorphReference>,
-      {
-        relation: TRelationKind;
-        target: TTarget;
-        morphBy?: Utils.Guard.Never<
-          Attribute.GetKeysByType<TTarget, 'relation', { relation: RelationKind.MorphOwner }>,
-          string
-        >;
-      }
-    >
+      MorphReferenceProperties<Utils.Cast<TRelationKind, RelationKind.MorphReference>, TTarget>
+    ],
+    [
+      Utils.Expression.Extends<TRelationKind, RelationKind.MorphOwner>,
+      MorphOwnerProperties<Utils.Cast<TRelationKind, RelationKind.MorphOwner>>
+    ]
   ]
 >;
 
+export type AllRelationProperties<TTarget extends Common.UID.Schema> =
+  | BiDirectionalProperties<RelationKind.BiDirectional, TTarget>
+  | XWayProperties<RelationKind.XWay, TTarget>
+  | MorphReferenceProperties<RelationKind.MorphReference, TTarget>
+  | MorphOwnerProperties<RelationKind.MorphOwner>;
+
+type BiDirectionalProperties<
+  TRelationKind extends RelationKind.BiDirectional,
+  TTarget extends Common.UID.Schema
+> = {
+  relation: TRelationKind;
+  target: TTarget;
+} & Utils.XOR<{ inversedBy?: string }, { mappedBy?: string }>;
+
+type XWayProperties<TRelationKind extends RelationKind.XWay, TTarget extends Common.UID.Schema> = {
+  relation: TRelationKind;
+  target: TTarget;
+};
+
+type MorphReferenceProperties<
+  TRelationKind extends RelationKind.MorphReference,
+  TTarget extends Common.UID.Schema
+> = {
+  relation: TRelationKind;
+  target: TTarget;
+  morphBy?: Utils.Guard.Never<
+    Attribute.GetKeysByType<TTarget, 'relation', { relation: RelationKind.MorphOwner }>,
+    string
+  >;
+};
+
+type MorphOwnerProperties<TRelationKind extends RelationKind.MorphOwner> = {
+  relation: TRelationKind;
+};
+
 export type RelationsKeysFromTo<
   TTarget extends Common.UID.Schema,
   TOrigin extends Common.UID.Schema
-> = keyof PickRelationsFromTo<TTarget, TOrigin>;
+> = Utils.Guard.Never<keyof PickRelationsFromTo<TTarget, TOrigin>, string>;
 
 export type PickRelationsFromTo<
   TTarget extends Common.UID.Schema,
@@ -76,6 +102,14 @@ export type GetRelationValue<TAttribute extends Attribute.Attribute> = TAttribut
   ? RelationValue<TRelationKind, TTarget>
   : never;
 
+export type GetRelationTarget<TAttribute extends Attribute.Attribute> = TAttribute extends Relation<
+  infer _TOrigin,
+  infer _TRelationKind,
+  infer TTarget
+>
+  ? TTarget
+  : never;
+
 export module RelationKind {
   type GetOppositePlurality<TPlurality extends RelationKind.Left | RelationKind.Right> = {
     one: 'many';
@@ -96,9 +130,16 @@ export module RelationKind {
   export type XWay = `${RelationKind.Left}Way`;
 
   export type BiDirectional = `${RelationKind.Left}To${RelationKind.Right}`;
-  export type UniDirectional = RelationKind.Morph | RelationKind.XWay;
+  export type UniDirectional = RelationKind.MorphReference | RelationKind.XWay;
+
+  export type Any = RelationKind.BiDirectional | RelationKind.Morph | RelationKind.XWay;
+
+  export type WithTarget =
+    | RelationKind.BiDirectional
+    | RelationKind.XWay
+    | RelationKind.MorphReference;
 
-  export type Any = RelationKind.BiDirectional | RelationKind.UniDirectional;
+  export type WithoutTarget = RelationKind.MorphOwner;
 
   export type Reverse<TRelationKind extends RelationKind.Any> =
     TRelationKind extends `${infer TLeft extends RelationKind.Left}To${infer TRight extends RelationKind.Right}`

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

@@ -8,6 +8,6 @@ export type Time = Attribute.OfType<'time'> &
   Attribute.RequiredOption &
   Attribute.UniqueOption;
 
-export type TimeValue = string;
+export type TimeValue = globalThis.Date | string;
 
 export type GetTimeValue<T extends Attribute.Attribute> = T extends Time ? TimeValue : never;

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

@@ -8,7 +8,7 @@ export type Timestamp = Attribute.OfType<'timestamp'> &
   Attribute.RequiredOption &
   Attribute.UniqueOption;
 
-export type TimestampValue = string;
+export type TimestampValue = globalThis.Date | number | string;
 
 export type GetTimestampValue<T extends Attribute.Attribute> = T extends Timestamp
   ? TimestampValue

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

@@ -9,28 +9,23 @@ export interface UIDOptions {
 }
 
 export interface UIDProperties<
-  TOrigin extends Common.UID.Schema,
-  TTargetAttribute extends AllowedTargetAttributes<TOrigin>,
+  TTargetAttribute extends string = string,
   TOptions extends UIDOptions = UIDOptions
 > {
   targetField: TTargetAttribute;
   options: UIDOptions & TOptions;
 }
 
-export interface GenericUIDProperties<TOptions extends UIDOptions = UIDOptions> {
-  targetField?: string;
-  options: TOptions & UIDOptions;
-}
-
 export type UID<
-  TOrigin extends Common.UID.Schema | undefined = undefined,
-  TTargetAttribute extends AllowedTargetAttributes<TOrigin> = AllowedTargetAttributes<TOrigin>,
+  // TODO: V5:
+  // The TOrigin was used to narrow down the list of possible target attribute for a
+  // UID, but was removed due to circular dependency issues and will be removed in V5
+  _TOrigin extends Common.UID.Schema = never,
+  TTargetAttribute extends string = string,
   TOptions extends UIDOptions = UIDOptions
 > = Attribute.OfType<'uid'> &
   // Properties
-  (TOrigin extends Common.UID.Schema
-    ? UIDProperties<TOrigin, TTargetAttribute, TOptions>
-    : GenericUIDProperties<TOptions>) &
+  UIDProperties<TTargetAttribute, TOptions> &
   // Options
   Attribute.ConfigurableOption &
   Attribute.DefaultOption<UIDValue> &
@@ -38,11 +33,6 @@ export type UID<
   Attribute.PrivateOption &
   Attribute.RequiredOption;
 
-type AllowedTargetAttributes<TOrigin extends Common.UID.Schema | undefined> =
-  TOrigin extends Common.UID.Schema
-    ? Utils.Guard.Never<Attribute.GetKeysByType<TOrigin, 'string' | 'text'>, string>
-    : never;
-
 export type UIDValue = string;
 
 export type GetUIDValue<TAttribute extends Attribute.Attribute> = TAttribute extends UID<

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

@@ -28,9 +28,42 @@ export type GetAll<TSchemaUID extends Common.UID.Schema> = Utils.Get<
   'attributes'
 >;
 
+export type GetTarget<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID>> = Get<
+  TSchemaUID,
+  TKey
+> extends infer TAttribute extends Attribute.Attribute
+  ?
+      | Attribute.GetRelationTarget<TAttribute>
+      | Attribute.GetComponentTarget<TAttribute>
+      | Attribute.GetMediaTarget<TAttribute>
+  : never;
+
+export type GetMorphTargets<
+  TSchemaUID extends Common.UID.Schema,
+  TKey extends GetKeys<TSchemaUID>
+> = Get<TSchemaUID, TKey> extends infer TAttribute extends Attribute.Attribute
+  ? Attribute.GetDynamicZoneTargets<TAttribute>
+  : never;
+
 export type GetKeys<TSchemaUID extends Common.UID.Schema> = keyof GetAll<TSchemaUID>;
 
-export type GetValue<TAttribute extends Attribute.Attribute> =
+export type GetNonPopulatableKeys<TSchemaUID extends Common.UID.Schema> = GetKeysByType<
+  TSchemaUID,
+  Attribute.NonPopulatableKind
+>;
+
+export type GetPopulatableKeys<TSchemaUID extends Common.UID.Schema> = GetKeysByType<
+  TSchemaUID,
+  Attribute.PopulatableKind
+>;
+
+export type GetKeysWithTarget<TSchemaUID extends Common.UID.Schema> = keyof {
+  [key in GetKeys<TSchemaUID> as GetTarget<TSchemaUID, key> extends never ? never : key]: never;
+} extends infer TKey extends GetKeys<TSchemaUID>
+  ? TKey
+  : never;
+
+export type GetValue<TAttribute extends Attribute.Attribute, TGuard = unknown> = Utils.Guard.Never<
   | Attribute.GetBigIntegerValue<TAttribute>
   | Attribute.GetBooleanValue<TAttribute>
   | Attribute.GetComponentValue<TAttribute>
@@ -51,7 +84,9 @@ export type GetValue<TAttribute extends Attribute.Attribute> =
   | Attribute.GetDateValue<TAttribute>
   | Attribute.GetDateTimeValue<TAttribute>
   | Attribute.GetTimeValue<TAttribute>
-  | Attribute.GetTimestampValue<TAttribute>;
+  | Attribute.GetTimestampValue<TAttribute>,
+  TGuard
+>;
 
 export type GetValueByKey<
   TSchemaUID extends Common.UID.Schema,
@@ -63,7 +98,7 @@ export type GetValueByKey<
 export type GetValues<
   TSchemaUID extends Common.UID.Schema,
   TKey extends GetKeys<TSchemaUID> = GetKeys<TSchemaUID>
-> = {
+> = { id: number | `${number}` } & {
   // Handle required attributes
   [key in GetRequiredKeys<TSchemaUID> as key extends TKey ? key : never]-?: GetValueByKey<
     TSchemaUID,
@@ -79,10 +114,30 @@ export type GetValues<
 
 export type GetRequiredKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysBy<
   GetAll<TSchemaUID>,
-  { required: true }
+  Attribute.Required
 >;
 
-export type GetOptionalKeys<TSchemaUID extends Common.UID.Schema> = keyof Omit<
+export type GetOptionalKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysExcept<
   GetAll<TSchemaUID>,
-  GetRequiredKeys<TSchemaUID>
+  Attribute.Required
 >;
+
+export type HasTarget<
+  TSchemaUID extends Common.UID.Schema,
+  TField extends Attribute.GetKeys<TSchemaUID>
+> = GetTarget<TSchemaUID, TField> extends infer TTarget
+  ? Utils.Expression.And<
+      Utils.Expression.IsNotNever<TTarget>,
+      Utils.Expression.Extends<TTarget, Common.UID.Schema>
+    >
+  : Utils.Expression.False;
+
+export type HasMorphTargets<
+  TSchemaUID extends Common.UID.Schema,
+  TField extends Attribute.GetKeys<TSchemaUID>
+> = GetMorphTargets<TSchemaUID, TField> extends infer TMaybeTargets
+  ? Utils.Expression.And<
+      Utils.Expression.IsNotNever<TMaybeTargets>,
+      Utils.Expression.Extends<TMaybeTargets, Common.UID.Schema>
+    >
+  : Utils.Expression.False;

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

@@ -1,4 +1,16 @@
+import type { Attribute, Common, Utils } from '@strapi/strapi';
+
 export * from './controller';
 export * from './service';
 export * from './schema';
 export * as UID from './uid';
+
+/**
+ * Determines if the shared registries for components and content types have been extended or if they're still represented as loose mapped types
+ *
+ * Here we use the fact that once the registries are extended, Attribute.GetKeys<Common.UID.Schema> will resolve to either never or a more
+ * deterministic value rather than string | number which represent the keys of the initial mapped type (Component & ContentType's registries)
+ */
+export type AreSchemaRegistriesExtended = Utils.Expression.Not<
+  Utils.Expression.Extends<string | number, Attribute.GetKeys<Common.UID.Schema>>
+>;

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

@@ -41,22 +41,18 @@ export type Schema = Registry.Keys<
   UID.ContentType | UID.Component<ComponentCategory>
 >;
 
-export type IsCollectionType<TContentTypeUID extends ContentType> = Utils.Expression.Extends<
-  Shared.ContentTypes[TContentTypeUID],
-  SchemaNamespace.CollectionType
->;
+export type IsCollectionType<TSchemaUID extends Schema> = TSchemaUID extends CollectionType
+  ? Utils.Expression.Extends<Shared.ContentTypes[TSchemaUID], SchemaNamespace.CollectionType>
+  : Utils.Expression.False;
 
-export type IsSingleType<TContentTypeUID extends ContentType> = Utils.Expression.Extends<
-  Shared.ContentTypes[TContentTypeUID],
-  SchemaNamespace.SingleType
->;
+export type IsSingleType<TSchemaUID extends Schema> = TSchemaUID extends SingleType
+  ? Utils.Expression.Extends<Shared.ContentTypes[TSchemaUID], SchemaNamespace.SingleType>
+  : Utils.Expression.False;
 
-export type IsComponent<TComponentUID extends Component> = Utils.Expression.Extends<
-  Shared.Components[TComponentUID],
-  SchemaNamespace.Component
->;
+export type IsComponent<TSchemaUID extends Schema> = TSchemaUID extends Component
+  ? Utils.Expression.Extends<Shared.Components[TSchemaUID], SchemaNamespace.Component>
+  : Utils.Expression.False;
 
-export type IsContentType<TContentTypeUID extends ContentType> = Utils.Expression.Or<
-  IsCollectionType<TContentTypeUID>,
-  IsSingleType<TContentTypeUID>
->;
+export type IsContentType<TSchemaUID extends Schema> = TSchemaUID extends ContentType
+  ? Utils.Expression.Or<IsCollectionType<TSchemaUID>, IsSingleType<TSchemaUID>>
+  : Utils.Expression.False;

package/lib/types/core/index.d.ts

@@ -1,5 +1,6 @@
 export * as Attribute from './attributes';
 export * as Schema from './schemas';
+export * as Plugin from './plugins';
 export * from './strapi';
 
 export * as Common from './common';

package/lib/types/core/plugins/index.d.ts

@@ -0,0 +1,16 @@
+import type { Common, Shared, Utils } from '@strapi/strapi';
+
+export type IsEnabled<
+  TName extends keyof any,
+  TSchemaUID extends Common.UID.Schema
+> = TName extends keyof Shared.PluginActivation
+  ? Shared.PluginActivation[TName] extends infer TRule
+    ? Utils.Expression.Or<
+        Utils.Expression.Not<Common.AreSchemaRegistriesExtended>,
+        Utils.Expression.Extends<
+          Common.Schemas[TSchemaUID]['pluginOptions'],
+          { [key in TName]: TRule }
+        >
+      >
+    : false
+  : false;

package/lib/types/core/schemas/index.d.ts

@@ -89,6 +89,7 @@ export interface Options {
   draftAndPublish?: boolean;
   populateCreatorFields?: boolean;
   comment?: string;
+  version?: string;
 }
 
 export interface PluginOptions {}

package/lib/types/core/strapi/index.d.ts

@@ -1,5 +1,5 @@
 import type { Database } from '@strapi/database';
-import type { Shared, Common } from '@strapi/strapi';
+import type { Comomn, EntityService, Shared } from '@strapi/strapi';
 
 // TODO move custom fields types to a separate file
 interface CustomFieldServerOptions {
@@ -65,6 +65,11 @@ export interface Strapi {
    */
   readonly sanitizers: any;
 
+  /**
+   * Getter for the Strapi validators container
+   */
+  readonly validators: any;
+
   /**
    * Getter for the Strapi services container
    *
@@ -412,7 +417,7 @@ export interface Strapi {
   /**
    * Entity Service instance
    */
-  entityService: any;
+  entityService: EntityService.EntityService;
 }
 
 export interface Lifecycles {

package/lib/types/core-api/controller.d.ts

@@ -11,34 +11,36 @@ export interface Base {
   transformResponse<TData, TResponse>(data: TData, meta: object): TResponse;
   sanitizeOutput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
   sanitizeInput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
-  sanitizeQuery<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
+  sanitizeQuery<TData>(ctx: ExtendableContext): Promise<TData>;
+  validateInput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
+  validateQuery<TData>(ctx: ExtendableContext): Promise<TData>;
 }
 
 /**
  * Generic controller structure
  */
 export type Generic = {
-  [name: string]: Common.ControllerHandler<unknown>;
+  [name: string]: Common.ControllerHandler;
 };
 
 /**
  * Core-API collection type controller
  */
 export interface CollectionType extends Base {
-  find?: Common.ControllerHandler<unknown>;
-  findOne?: Common.ControllerHandler<unknown>;
-  create?: Common.ControllerHandler<unknown>;
-  update?: Common.ControllerHandler<unknown>;
-  delete?: Common.ControllerHandler<unknown>;
+  find?: Common.ControllerHandler;
+  findOne?: Common.ControllerHandler;
+  create?: Common.ControllerHandler;
+  update?: Common.ControllerHandler;
+  delete?: Common.ControllerHandler;
 }
 
 /**
  * Core-API single type controller
  */
 export interface SingleType extends Base {
-  find?: Common.ControllerHandler<unknown>;
-  update?: Common.ControllerHandler<unknown>;
-  delete?: Common.ControllerHandler<unknown>;
+  find?: Common.ControllerHandler;
+  update?: Common.ControllerHandler;
+  delete?: Common.ControllerHandler;
 }
 
 export type ContentType<T extends Common.UID.ContentType> = Utils.Expression.MatchFirst<

package/lib/types/index.d.ts

@@ -1,6 +1,8 @@
 // Exports from core should already be modules
 export * from './core';
 
+export * as EntityService from '../services/entity-service';
+
 export * as CoreApi from './core-api';
 export * as Utils from './utils';
 export * as Shared from './shared';

package/lib/types/shared/entity-service.d.ts

@@ -0,0 +1 @@
+export interface EntityServicePluginParams {}

package/lib/types/shared/index.d.ts

@@ -1 +1,3 @@
 export * from './registries';
+export * from './entity-service';
+export * from './plugins';

package/lib/types/shared/plugins.d.ts

@@ -0,0 +1,3 @@
+export interface PluginActivation {
+  [key: keyof any]: unknown;
+}

package/lib/types/utils/expression.d.ts

@@ -4,8 +4,20 @@ export type True = true;
 export type False = false;
 export type BooleanValue = True | False;
 
+export type IsNever<TValue> = StrictEqual<TValue, never>;
+
+export type IsNotNever<TValue> = Not<IsNever<TValue>>;
+
+export type IsTrue<TValue> = [TValue] extends [True] ? True : False;
+
+export type IsFalse<TValue> = [TValue] extends [False] ? True : False;
+
+export type StrictEqual<TValue, TMatch> = And<Extends<TValue, TMatch>, Extends<TMatch, TValue>>;
+
 export type Extends<TLeft, TRight> = [TLeft] extends [TRight] ? True : False;
 
+export type DoesNotExtends<TLeft, TRight> = Not<Extends<TLeft, TRight>>;
+
 export type Not<TExpression extends BooleanValue> = If<TExpression, False, True>;
 
 export type If<TExpression extends BooleanValue, TOnTrue, TOnFalse = never> = [
@@ -27,18 +39,30 @@ export type MatchFirst<TTests extends Test[], TDefault = never> = TTests extends
     : never
   : never;
 
-export type MatchAll<TTests extends Test[], TDefault = never> = TTests extends [
+export type MatchAllUnion<TTests extends Test[], TDefault = never> = TTests extends [
   infer THead extends Test,
   ...infer TTail extends Test[]
 ]
   ? THead extends Test<infer TExpression, infer TValue>
     ? Utils.Guard.Never<
-        If<TExpression, TValue> | If<Utils.Array.IsNotEmpty<TTail>, MatchAll<TTail, TDefault>>,
+        If<TExpression, TValue> | If<Utils.Array.IsNotEmpty<TTail>, MatchAllUnion<TTail, TDefault>>,
         TDefault
       >
     : never
   : never;
 
+export type MatchAllIntersect<TTests extends Test[], TDefault = unknown> = TTests extends [
+  infer THead extends Test,
+  ...infer TTail extends Test[]
+]
+  ? THead extends Test<infer TExpression, infer TValue>
+    ? // Actual test case evaluation
+      If<TExpression, TValue, TDefault> &
+        // Recursion / End of recursion
+        If<Utils.Array.IsNotEmpty<TTail>, MatchAllIntersect<TTail, TDefault>, TDefault>
+    : TDefault
+  : TDefault;
+
 export type Test<TExpression extends BooleanValue = BooleanValue, TValue = unknown> = [
   TExpression,
   TValue
@@ -58,11 +82,10 @@ export type Every<TExpressions extends BooleanValue[]> = TExpressions extends [
   ? If<Utils.Array.IsNotEmpty<TTail>, And<THead, Every<TTail>>, And<THead, True>>
   : never;
 
-export type And<TLeft extends BooleanValue, TRight extends BooleanValue> = Extends<
-  Extends<TLeft, True> | Extends<TRight, True>,
-  True
+export type And<TLeft extends BooleanValue, TRight extends BooleanValue> = IsTrue<
+  IsTrue<TLeft> | IsTrue<TRight>
 >;
 
 export type Or<TLeft extends BooleanValue, TRight extends BooleanValue> = Not<
-  Extends<Extends<TLeft, True> | Extends<TRight, True>, False>
+  IsFalse<IsTrue<TLeft> | IsTrue<TRight>>
 >;

package/lib/types/utils/guard.d.ts

@@ -1,3 +1,5 @@
+import type { Utils } from '@strapi/strapi';
+
 /**
  * Assign a default value `TDefault` to `TValue` if `TValue` is of type `never`
  *
@@ -11,4 +13,15 @@
  * type X = Never<never, string>
  * // string
  */
-export type Never<TValue, TDefault = unknown> = [TValue] extends [never] ? TDefault : TValue;
+export type Never<TValue, TFallback = unknown> = OfTypes<[never], TValue, TFallback>;
+
+export type OfTypes<TTypes extends unknown[], TValue, TFallback = unknown> = TTypes extends [
+  infer THead extends unknown,
+  ...infer TTail extends unknown[]
+]
+  ? Utils.Expression.If<
+      Utils.Expression.StrictEqual<TValue, THead>,
+      TFallback,
+      Utils.Expression.If<Utils.Array.IsNotEmpty<TTail>, OfTypes<TTail, TValue, TFallback>, TValue>
+    >
+  : never;

package/lib/types/utils/index.d.ts

@@ -17,3 +17,11 @@ export * as Expression from './expression';
  * // 'foo'
  */
 export type Get<TValue, TKey extends keyof TValue> = TValue[TKey];
+
+export type Without<TLeft, TRight> = { [key in Exclude<keyof TLeft, keyof TRight>]?: never };
+
+export type XOR<TLeft, TRight> = TLeft | TRight extends object
+  ? (Without<TLeft, TRight> & TRight) | (Without<TRight, TLeft> & TLeft)
+  : TLeft | TRight;
+
+export type Cast<TValue, TType> = TValue extends TType ? TValue : never;

package/lib/types/utils/object.d.ts

@@ -1,5 +1,5 @@
 /**
- * Retrieve object's (`TValue`) keys if they extends the given `TTest` type.
+ * Retrieve object's (`TValue`) keys if they extend the given `TTest` type.
  *
  * @example
  * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
@@ -14,6 +14,22 @@ export type KeysBy<TValue, TTest> = {
   [key in keyof TValue]: TValue[key] extends TTest ? key : never;
 }[keyof TValue];
 
+/**
+ * Retrieve object's (`TValue`) keys if they don't extend the given `TTest` type.
+ *
+ * @example
+ * type X = KeysExcept<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
+ * // foobar
+ *
+ * type Base = { x: 'foo' | 'bar' };
+ * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
+ * type X = KeysBy<Obj, Base>
+ * // 'other'
+ */
+export type KeysExcept<TValue, TTest> = {
+  [key in keyof TValue]: TValue[key] extends TTest ? never : key;
+}[keyof TValue];
+
 /**
  * Retrieve object's (`TValue`) properties if their value extends the given `TTest` type.
  *
@@ -27,3 +43,21 @@ export type KeysBy<TValue, TTest> = {
  * // { foo: { x: 'foo' }, bar: { x: 'bar' } }
  */
 export type PickBy<TValue, TTest> = Pick<TValue, KeysBy<TValue, TTest>>;
+
+/**
+ * Retrieve object's (`TObject`) values
+ *
+ * @example
+ * type X = Values<{ foo: 'bar', bar: 'foo', foobar: 2 }>
+ * // 'bar' | 'foo' | 2
+ *
+ * type Y = Values<{ foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } }>
+ * // { x: 'foo' } | { x: 'bar' } | { x: '42' }
+ */
+export type Values<TObject extends object> = TObject[keyof TObject];
+
+export type DeepPartial<TObject> = TObject extends object
+  ? {
+      [TKey in keyof TObject]?: DeepPartial<TObject[TKey]>;
+    }
+  : TObject;