@strapi/types 0.0.0 → 4.14.0

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

@@ -0,0 +1,58 @@
+/**
+ * Strapi custom scalar types
+ */
+import type { Attribute, Common } from '..';
+/**
+ * Setters for the attributes options
+ */
+export type Required = {
+    required: true;
+};
+export type NonRequired = {
+    required: false;
+};
+export type Private = {
+    private: true;
+};
+export type NonPrivate = {
+    private: false;
+};
+export type Unique = {
+    unique: true;
+};
+export type NonUnique = {
+    unique: false;
+};
+export type Configurable = {
+    configurable: true;
+};
+export type NonConfigurable = {
+    configurable: false;
+};
+export type Writable = {
+    writable: true;
+};
+export type NonWritable = {
+    writable: false;
+};
+export type Visible = {
+    visible: true;
+};
+export type NonVisible = {
+    visible: false;
+};
+export type CustomField<TKind extends string, TOptions extends object | undefined = undefined> = {
+    customField: TKind;
+    options?: TOptions;
+};
+export type SetMinMax<TConfig extends Attribute.MinMaxOption<TType>, TType = number> = TConfig;
+export type SetMinMaxLength<TConfig extends Attribute.MinMaxLengthOption> = TConfig;
+export type SetPluginOptions<TConfig extends object = object> = {
+    pluginOptions?: TConfig;
+};
+export type DefaultTo<T> = {
+    default: T;
+};
+export type Any = Attribute.BigInteger | Attribute.Boolean | Attribute.Blocks | Attribute.Component<Common.UID.Component, boolean> | Attribute.DateTime | Attribute.Date | Attribute.Decimal | Attribute.DynamicZone | Attribute.Email | Attribute.Enumeration<string[]> | Attribute.Float | Attribute.Integer | Attribute.JSON | Attribute.Media<Attribute.MediaKind | undefined, boolean> | Attribute.Password | 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>;
+export type PopulatableKind = Extract<Attribute.Kind, 'relation' | 'component' | 'dynamiczone' | 'media'>;
+export type NonPopulatableKind = Exclude<Attribute.Kind, 'relation' | 'component' | 'dynamiczone' | 'media'>;

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

@@ -0,0 +1,10 @@
+import type { Attribute, Common } from '..';
+import type { Utils } from '../..';
+export interface ComponentProperties<TComponentUID extends Common.UID.Component, TRepeatable extends Utils.Expression.BooleanValue = Utils.Expression.False> {
+    component: TComponentUID;
+    repeatable?: TRepeatable;
+}
+export type Component<TComponentUID extends Common.UID.Component = Common.UID.Component, TRepeatable extends Utils.Expression.BooleanValue = Utils.Expression.False> = Attribute.OfType<'component'> & ComponentProperties<TComponentUID, TRepeatable> & Attribute.ConfigurableOption & Attribute.MinMaxOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type ComponentValue<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;
+export type GetComponentTarget<TAttribute extends Attribute.Attribute> = TAttribute extends Component<infer TComponentUID, infer _TRepeatable> ? TComponentUID : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type DateTime = Attribute.OfType<'datetime'> & Attribute.ConfigurableOption & Attribute.DefaultOption<DateTimeValue> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.UniqueOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type DateTimeValue = globalThis.Date | string;
+export type GetDateTimeValue<T extends Attribute.Attribute> = T extends DateTime ? DateTimeValue : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Date = Attribute.OfType<'date'> & Attribute.ConfigurableOption & Attribute.DefaultOption<DateValue> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.UniqueOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type DateValue = globalThis.Date | string;
+export type GetDateValue<T extends Attribute.Attribute> = T extends Date ? DateValue : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Decimal = Attribute.OfType<'decimal'> & Attribute.ConfigurableOption & Attribute.DefaultOption<DecimalValue> & Attribute.MinMaxOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption & Attribute.UniqueOption;
+export type DecimalValue = number;
+export type GetDecimalValue<T extends Attribute.Attribute> = T extends Decimal ? DecimalValue : never;

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

@@ -0,0 +1,12 @@
+import type { Attribute, Common } from '..';
+import type { Utils } from '../..';
+export interface DynamicZoneProperties<TComponentsUID extends Common.UID.Component[]> {
+    components: TComponentsUID;
+}
+export type DynamicZone<TComponentsUID extends Common.UID.Component[] = Common.UID.Component[]> = Attribute.OfType<'dynamiczone'> & DynamicZoneProperties<TComponentsUID> & Attribute.ConfigurableOption & Attribute.MinMaxOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+type DynamicZoneValue<TComponentsUID extends Common.UID.Component[]> = Array<Utils.Array.Values<TComponentsUID> extends infer TComponentUID ? TComponentUID extends Common.UID.Component ? Attribute.GetValues<TComponentUID> & {
+    __component: TComponentUID;
+} : never : never>;
+export type GetDynamicZoneValue<TAttribute extends Attribute.Attribute> = 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;
+export {};

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Email = Attribute.OfType<'email'> & Attribute.ConfigurableOption & Attribute.DefaultOption<EmailValue> & Attribute.MinMaxLengthOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.UniqueOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type EmailValue = string;
+export type GetEmailValue<T extends Attribute.Attribute> = T extends Email ? EmailValue : never;

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

@@ -0,0 +1,8 @@
+import type { Attribute } from '..';
+import type { Utils } from '../..';
+export interface EnumerationProperties<TValues extends string[] = []> {
+    enum: TValues;
+}
+export type Enumeration<TValues extends string[] = []> = Attribute.OfType<'enumeration'> & EnumerationProperties<TValues> & Attribute.ConfigurableOption & Attribute.DefaultOption<TValues[number]> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type EnumerationValue<TValues extends string[]> = Utils.Array.Values<TValues>;
+export type GetEnumerationValue<TAttribute extends Attribute.Attribute> = TAttribute extends Enumeration<infer TValues> ? EnumerationValue<TValues> : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Float = Attribute.OfType<'float'> & Attribute.ConfigurableOption & Attribute.DefaultOption<FloatValue> & Attribute.MinMaxOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption & Attribute.UniqueOption;
+export type FloatValue = number;
+export type GetFloatValue<T extends Attribute.Attribute> = T extends Float ? FloatValue : never;

package/dist/types/core/attributes/index.d.ts

@@ -0,0 +1,25 @@
+export * from './base';
+export * from './biginteger';
+export * from './boolean';
+export * from './blocks';
+export * from './component';
+export * from './decimal';
+export * from './dynamic-zone';
+export * from './enumeration';
+export * from './float';
+export * from './integer';
+export * from './json';
+export * from './media';
+export * from './password';
+export * from './relation';
+export * from './richtext';
+export * from './string';
+export * from './text';
+export * from './uid';
+export * from './email';
+export * from './date';
+export * from './date-time';
+export * from './timestamp';
+export * from './time';
+export * from './common';
+export * from './utils';

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Integer = Attribute.OfType<'integer'> & Attribute.ConfigurableOption & Attribute.DefaultOption<IntegerValue> & Attribute.MinMaxOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption & Attribute.UniqueOption;
+export type IntegerValue = number;
+export type GetIntegerValue<T extends Attribute.Attribute> = T extends Integer ? IntegerValue : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type JSON = Attribute.OfType<'json'> & Attribute.ConfigurableOption & Attribute.RequiredOption & Attribute.PrivateOption & Attribute.WritableOption & Attribute.VisibleOption & Attribute.DefaultOption<JsonValue>;
+export type JsonValue<T extends object = object> = T;
+export type GetJsonValue<T extends Attribute.Attribute> = T extends JSON ? JsonValue : never;

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

@@ -0,0 +1,12 @@
+import type { Attribute } from '..';
+import type { Utils } from '../..';
+export type MediaTarget = 'plugin::upload.file';
+export type MediaKind = 'images' | 'videos' | 'files' | 'audios';
+export interface MediaProperties<TKind extends MediaKind | undefined = undefined, TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False> {
+    allowedTypes?: TKind | TKind[];
+    multiple?: TMultiple;
+}
+export type Media<TKind extends MediaKind | undefined = undefined, TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False> = Attribute.OfType<'media'> & MediaProperties<TKind, TMultiple> & Attribute.ConfigurableOption & Attribute.RequiredOption & Attribute.PrivateOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type MediaValue<TMultiple extends Utils.Expression.BooleanValue = Utils.Expression.False> = Utils.Expression.If<TMultiple, any[], any>;
+export type GetMediaValue<TAttribute extends Attribute.Attribute> = TAttribute extends Media<infer _TKind, infer TMultiple> ? MediaValue<TMultiple> : never;
+export type GetMediaTarget<TAttribute extends Attribute.Attribute> = TAttribute extends Media<infer _TKind, infer _TMultiple> ? MediaTarget : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Password = Attribute.OfType<'password'> & Attribute.ConfigurableOption & Attribute.DefaultOption<PasswordValue> & Attribute.MinMaxLengthOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type PasswordValue = string;
+export type GetPasswordValue<T extends Attribute.Attribute> = T extends Password ? PasswordValue : never;

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

@@ -0,0 +1,75 @@
+import type { Attribute, Common } from '..';
+import type { Utils } from '../..';
+export type Relation<_TOrigin extends Common.UID.Schema = Common.UID.Schema, TRelationKind extends RelationKind.Any = RelationKind.Any, TTarget extends Common.UID.Schema = Common.UID.Schema> = Attribute.OfType<'relation'> & Utils.Guard.Never<RelationProperties<TRelationKind, TTarget>, AllRelationProperties<TTarget>> & Attribute.ConfigurableOption & Attribute.PrivateOption & Attribute.WritableOption & Attribute.VisibleOption & Attribute.RequiredOption;
+export type RelationProperties<TRelationKind extends RelationKind.Any, TTarget extends Common.UID.Schema> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.Extends<TRelationKind, RelationKind.BiDirectional>,
+        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>,
+        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<'morphToOne'> | MorphOwnerProperties<'morphToMany'>;
+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> = Utils.Guard.Never<keyof PickRelationsFromTo<TTarget, TOrigin>, string>;
+export type PickRelationsFromTo<TTarget extends Common.UID.Schema, TOrigin extends Common.UID.Schema> = Attribute.GetByType<TTarget, 'relation', {
+    target: TOrigin;
+}>;
+export type RelationPluralityModifier<TRelationKind extends RelationKind.Any, TValue> = TRelationKind extends Utils.String.Suffix<string, 'Many'> ? TValue[] : TValue;
+export type RelationValue<TRelationKind extends RelationKind.Any, TTarget extends Common.UID.Schema> = RelationPluralityModifier<TRelationKind, Attribute.GetValues<TTarget>>;
+export type GetRelationValue<TAttribute extends Attribute.Attribute> = TAttribute extends Relation<infer _TOrigin, infer TRelationKind, infer TTarget> ? RelationValue<TRelationKind, TTarget> : never;
+export type GetRelationTarget<TAttribute extends Attribute.Attribute> = TAttribute extends Relation<infer _TOrigin, infer _TRelationKind, infer TTarget> ? TTarget : never;
+export declare namespace 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.MorphReference | RelationKind.XWay;
+    export type Any = RelationKind.BiDirectional | RelationKind.Morph | RelationKind.XWay;
+    export type WithTarget = RelationKind.BiDirectional | RelationKind.XWay | RelationKind.MorphReference;
+    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}` ? Utils.Expression.If<Utils.Expression.Extends<Uppercase<TLeft>, Uppercase<TRight>>, TRelationKind, `${GetOppositePlurality<TLeft>}To${GetOppositePlurality<TRight>}`> : TRelationKind;
+    export {};
+}
+export {};

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type RichText = Attribute.OfType<'richtext'> & Attribute.ConfigurableOption & Attribute.DefaultOption<RichTextValue> & Attribute.MinMaxLengthOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type RichTextValue = string;
+export type GetRichTextValue<T extends Attribute.Attribute> = T extends RichText ? RichTextValue : never;

package/dist/types/core/attributes/string.d.ts

@@ -0,0 +1,9 @@
+import type { Attribute } from '..';
+export interface StringProperties {
+    regex?: RegExp;
+}
+type StringAttribute = Attribute.OfType<'string'> & StringProperties & Attribute.ConfigurableOption & Attribute.DefaultOption<StringValue> & Attribute.MinMaxLengthOption & Attribute.PrivateOption & Attribute.UniqueOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type StringValue = string;
+export type GetStringValue<T extends Attribute.Attribute> = T extends StringAttribute ? StringValue : never;
+export type String = StringAttribute;
+export {};

package/dist/types/core/attributes/text.d.ts

@@ -0,0 +1,7 @@
+import type { Attribute } from '..';
+export interface TextProperties {
+    regex?: RegExp;
+}
+export type Text = Attribute.OfType<'text'> & TextProperties & Attribute.ConfigurableOption & Attribute.DefaultOption<TextValue> & Attribute.MinMaxLengthOption & Attribute.PrivateOption & Attribute.UniqueOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type TextValue = string;
+export type GetTextValue<T extends Attribute.Attribute> = T extends Text ? TextValue : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Time = Attribute.OfType<'time'> & Attribute.ConfigurableOption & Attribute.DefaultOption<TimeValue> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.UniqueOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type TimeValue = globalThis.Date | string;
+export type GetTimeValue<T extends Attribute.Attribute> = T extends Time ? TimeValue : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Timestamp = Attribute.OfType<'timestamp'> & Attribute.ConfigurableOption & Attribute.DefaultOption<TimestampValue> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.UniqueOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type TimestampValue = globalThis.Date | number | string;
+export type GetTimestampValue<T extends Attribute.Attribute> = T extends Timestamp ? TimestampValue : never;

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

@@ -0,0 +1,15 @@
+import type { Attribute, Common } from '..';
+export interface UIDOptions {
+    separator?: string;
+    lowercase?: boolean;
+    decamelize?: boolean;
+    customReplacements?: Array<[string, string]>;
+    preserveLeadingUnderscore?: boolean;
+}
+export interface UIDProperties<TTargetAttribute extends string = string, TOptions extends UIDOptions = UIDOptions> {
+    targetField?: TTargetAttribute;
+    options?: UIDOptions & TOptions;
+}
+export type UID<_TOrigin extends Common.UID.Schema = never, TTargetAttribute extends string = string, TOptions extends UIDOptions = UIDOptions> = Attribute.OfType<'uid'> & UIDProperties<TTargetAttribute, TOptions> & Attribute.ConfigurableOption & Attribute.DefaultOption<UIDValue> & Attribute.MinMaxLengthOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type UIDValue = string;
+export type GetUIDValue<TAttribute extends Attribute.Attribute> = TAttribute extends UID<infer _TOrigin, infer _TTargetAttribute> ? UIDValue : never;

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

@@ -0,0 +1,27 @@
+import type { Attribute, Common } from '..';
+import type { Utils } from '../..';
+export type GetKeysByType<TSchemaUID extends Common.UID.Schema, TKind extends Attribute.Kind, TCondition = never> = Utils.Object.KeysBy<GetAll<TSchemaUID>, Attribute.OfType<TKind> & Utils.Guard.Never<TCondition, unknown>, string>;
+export type GetByType<TSchemaUID extends Common.UID.Schema, TKind extends Attribute.Kind, TCondition = never> = Utils.Object.PickBy<GetAll<TSchemaUID>, Attribute.OfType<TKind> & Utils.Guard.Never<TCondition, unknown>>;
+export type Get<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID>> = Utils.Get<GetAll<TSchemaUID>, TKey>;
+export type GetAll<TSchemaUID extends Common.UID.Schema> = Utils.Get<Common.Schemas[TSchemaUID], '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> & string;
+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.GetBlocksValue<TAttribute> | Attribute.GetComponentValue<TAttribute> | Attribute.GetDecimalValue<TAttribute> | Attribute.GetDynamicZoneValue<TAttribute> | Attribute.GetEnumerationValue<TAttribute> | Attribute.GetEmailValue<TAttribute> | Attribute.GetFloatValue<TAttribute> | Attribute.GetIntegerValue<TAttribute> | Attribute.GetJsonValue<TAttribute> | Attribute.GetMediaValue<TAttribute> | Attribute.GetPasswordValue<TAttribute> | Attribute.GetRelationValue<TAttribute> | Attribute.GetRichTextValue<TAttribute> | Attribute.GetStringValue<TAttribute> | Attribute.GetTextValue<TAttribute> | Attribute.GetUIDValue<TAttribute> | Attribute.GetDateValue<TAttribute> | Attribute.GetDateTimeValue<TAttribute> | Attribute.GetTimeValue<TAttribute> | Attribute.GetTimestampValue<TAttribute>, TGuard>;
+export type GetValueByKey<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID>> = Get<TSchemaUID, TKey> extends infer TAttribute extends Attribute.Attribute ? GetValue<TAttribute> : never;
+export type GetValues<TSchemaUID extends Common.UID.Schema, TKey extends GetKeys<TSchemaUID> = GetKeys<TSchemaUID>> = {
+    id: number | `${number}`;
+} & {
+    [key in GetRequiredKeys<TSchemaUID> as key extends TKey ? key : never]-?: GetValueByKey<TSchemaUID, key>;
+} & {
+    [key in GetOptionalKeys<TSchemaUID> as key extends TKey ? key : never]?: GetValueByKey<TSchemaUID, key>;
+};
+export type GetRequiredKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysBy<GetAll<TSchemaUID>, Attribute.Required, string>;
+export type GetOptionalKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysExcept<GetAll<TSchemaUID>, Attribute.Required, string>;
+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/dist/types/core/commands/index.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+export type AddCommandOptions = {
+    command: Command;
+    argv: Record<number, string>;
+};

package/dist/types/core/common/api.d.ts

@@ -0,0 +1,3 @@
+import type { Common } from '..';
+export interface API extends Common.Module {
+}

package/dist/types/core/common/controller.d.ts

@@ -0,0 +1,5 @@
+import type { Context, Next } from 'koa';
+export interface ControllerHandler<TResponse = unknown> {
+    (context: Context, next: Next): Promise<TResponse | void> | TResponse | void;
+}
+export type Controller = Record<string, ControllerHandler>;

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

@@ -0,0 +1,18 @@
+import type { Utils, Attribute, Common } from '../..';
+export * from './controller';
+export * from './middleware';
+export * from './policy';
+export * from './service';
+export * from './router';
+export * from './schema';
+export * as UID from './uid';
+export * from './plugin';
+export * from './module';
+export * from './api';
+/**
+ * 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/dist/types/core/common/middleware.d.ts

@@ -0,0 +1,7 @@
+import type Koa from 'koa';
+import type { Strapi } from '../../..';
+export type MiddlewareFactory<T = any> = (config: T, ctx: {
+    strapi: Strapi;
+}) => MiddlewareHandler | void;
+export type MiddlewareHandler = Koa.Middleware;
+export type Middleware = MiddlewareHandler | MiddlewareFactory;

package/dist/types/core/common/module.d.ts

@@ -0,0 +1,24 @@
+import type { Common, Schema } from '..';
+import type { Strapi } from '../../..';
+export interface Module {
+    bootstrap: ({ strapi }: {
+        strapi: Strapi;
+    }) => void | Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: Strapi;
+    }) => void | Promise<void>;
+    register: ({ strapi }: {
+        strapi: Strapi;
+    }) => void | Promise<void>;
+    config<TDefault = unknown, TResult = unknown>(path: string, defaultValue?: TDefault): TResult;
+    routes: Record<string, Common.Router>;
+    controllers: Record<string, Common.Controller>;
+    services: Record<string, Common.Service>;
+    policies: Record<string, Common.Policy>;
+    middlewares: Record<string, Common.Middleware>;
+    contentTypes: Record<string, {
+        schema: Schema.ContentType;
+    }>;
+    controller<T extends Common.Controller>(name: string): T;
+    service<T extends Common.Service>(name: string): T;
+}

package/dist/types/core/common/plugin.d.ts

@@ -0,0 +1,5 @@
+import type { Common } from '..';
+export type Plugin = Omit<Common.Module, 'routes'> & {
+    routes: Common.Route[] | Record<string, Common.Router>;
+    [key: string]: any;
+};

package/dist/types/core/common/policy.d.ts

@@ -0,0 +1,9 @@
+import { ExtendableContext } from 'koa';
+import type { Strapi } from '../../..';
+export type PolicyContext = Omit<ExtendableContext, 'is'> & {
+    type: string;
+    is(name: string): boolean;
+};
+export type Policy<T = unknown> = (ctx: PolicyContext, cfg: T, { strapi }: {
+    strapi: Strapi;
+}) => boolean | undefined;

package/dist/types/core/common/router.d.ts

@@ -0,0 +1,34 @@
+import type { MiddlewareHandler } from './middleware';
+export type RouterType = 'admin' | 'content-api';
+export type RouteInfo = {
+    apiName?: string;
+    pluginName?: string;
+    type?: string;
+};
+export type RouteConfig = {
+    prefix?: string;
+    middlewares?: Array<string | MiddlewareHandler>;
+    policies?: Array<string | {
+        name: string;
+        config: unknown;
+    }>;
+    auth?: false | {
+        scope?: string[];
+        strategies?: string[];
+    };
+};
+export type Route = {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    handler: string | MiddlewareHandler;
+    info: RouteInfo;
+    config?: RouteConfig;
+};
+export type RouteInput = Omit<Route, 'info'> & {
+    info?: Partial<RouteInfo>;
+};
+export type Router = {
+    type: RouterType;
+    prefix?: string;
+    routes: Route[];
+};

package/dist/types/core/common/schema.d.ts

@@ -0,0 +1,2 @@
+import type { ContentTypes, Components } from '../../shared';
+export type Schemas = ContentTypes & Components;

package/dist/types/core/common/service.d.ts

@@ -0,0 +1,3 @@
+export type Service = {
+    [key: keyof any]: any;
+};

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

@@ -0,0 +1,15 @@
+import type { Shared, Schema as SchemaNamespace, Common, Registry, UID, Utils } from '../../..';
+export type Service = Registry.Keys<Shared.Services, UID.Service>;
+export type Controller = Registry.Keys<Shared.Controllers, UID.Controller>;
+export type Policy = Registry.Keys<Shared.Policies, UID.Policy>;
+export type Middleware = Registry.Keys<Shared.Middlewares, UID.Middleware>;
+export type ContentType = Registry.Keys<Shared.ContentTypes, UID.ContentType>;
+export type CollectionType = Utils.Guard.Never<Extract<Utils.Object.KeysBy<Shared.ContentTypes, SchemaNamespace.CollectionType>, ContentType>, ContentType>;
+export type SingleType = Utils.Guard.Never<Extract<Utils.Object.KeysBy<Shared.ContentTypes, SchemaNamespace.SingleType>, ContentType>, ContentType>;
+export type Component = Registry.Keys<Shared.Components, UID.Component>;
+export type ComponentCategory = Component extends UID.Component<infer TCategory> ? TCategory : never;
+export type Schema = Registry.Keys<Common.Schemas, UID.ContentType | UID.Component<ComponentCategory>>;
+export type IsCollectionType<TSchemaUID extends Schema> = TSchemaUID extends CollectionType ? Utils.Expression.Extends<Shared.ContentTypes[TSchemaUID], SchemaNamespace.CollectionType> : Utils.Expression.False;
+export type IsSingleType<TSchemaUID extends Schema> = TSchemaUID extends SingleType ? Utils.Expression.Extends<Shared.ContentTypes[TSchemaUID], SchemaNamespace.SingleType> : Utils.Expression.False;
+export type IsComponent<TSchemaUID extends Schema> = TSchemaUID extends Component ? Utils.Expression.Extends<Shared.Components[TSchemaUID], SchemaNamespace.Component> : Utils.Expression.False;
+export type IsContentType<TSchemaUID extends Schema> = TSchemaUID extends ContentType ? Utils.Expression.Or<IsCollectionType<TSchemaUID>, IsSingleType<TSchemaUID>> : Utils.Expression.False;

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

@@ -0,0 +1,17 @@
+/**
+ * Note: linting will erroneously raise errors if a namespaced type has the same name as on exported by Strapi
+ * To work around it, use a pattern such as:
+ *
+ * import * as PluginImport from './plugins'
+ * export type Plugin = typeof PluginImport
+ *
+ * which causes linting to see the namespaces correctly.
+ */
+export * as Attribute from './attributes';
+export * as Schema from './schemas';
+export * as Plugin from './plugins';
+export * from './strapi';
+export * as Common from './common';
+export * as Namespace from './namespace';
+export * as UID from './uid';
+export * as Registry from './registry';

package/dist/types/core/namespace.d.ts

@@ -0,0 +1,77 @@
+import type * as Utils from '../utils';
+/**
+ * Namespace for admin resources
+ */
+export type Admin = 'admin';
+/**
+ * Namespace for strapi internal resources
+ */
+export type Strapi = 'strapi';
+/**
+ * Namespace for scoped APIs resources
+ */
+export type API<T extends string = string> = `api${ColonsSeparator}${T}`;
+/**
+ * Namespace for scoped plugins resources
+ */
+export type Plugin<T extends string = string> = `plugin${ColonsSeparator}${T}`;
+/**
+ * Namespace for global resources
+ */
+export type Global = 'global';
+/**
+ * Represents any namespace
+ */
+export type Any = API | Plugin | Admin | Strapi | Global;
+/**
+ * Return a {@link Separator} based on the given {@link Any} ({@link DotSeparator} for {@link Scoped} and {@link ColonsSeparator} for regular ones)
+ *
+ * @example
+ * type S = GetSeparator<Admin>
+ * // ^ '::'
+ *
+ * type S = GetSeparator<API>
+ * // ^ '.'
+ *
+ * type S = GetSeparator<Admin | API>
+ * // ^ '.' | '::'
+ */
+export type GetSeparator<TNamespace extends Any = Any> = TNamespace extends Scoped ? DotSeparator : ColonsSeparator;
+/**
+ * Adds the corresponding separator (using {@link GetSeparator}) at the end of a namespace
+ *
+ * Warning: Using WithSeparator with a union type might produce undesired results as it'll distribute every matching suffix to every union member
+ *
+ * @example
+ * type T = WithSeparator<Admin>
+ * // ^ 'admin::'
+ *
+ * type T = WithSeparator<API>
+ * // ^ 'api::{string}.'
+ *
+ * type T = WithSeparator<Admin | API>
+ * // ^ 'admin::' | 'admin.' | 'api::{string}.' | 'api::{string}::'
+ *
+ * type T = WithSeparator<Admin> | WithSeparator<API>
+ * // ^ 'admin::' | 'api::{string}.'
+ */
+export type WithSeparator<TNamespace extends Any> = Utils.String.Suffix<TNamespace, GetSeparator<TNamespace>>;
+/**
+ * Represents namespaces composed of an origin and a scope, separated by colons
+ */
+export type Scoped<TOrigin extends string = string, TScope extends string = string> = Any & `${TOrigin}${ColonsSeparator}${TScope}`;
+/**
+ * Extract the scope from the given scoped namespace
+ */
+export type ExtractScope<TNamespace> = TNamespace extends `${string}${ColonsSeparator}${infer TScope}` ? TScope : never;
+/**
+ * Extract the origin from the given scoped namespace
+ */
+export type ExtractOrigin<TNamespace> = TNamespace extends `${infer TOrigin}${ColonsSeparator}${string}` ? TOrigin : never;
+/**
+ * Separators used to join the different parts of a namespace (e.g. building a uid)
+ */
+export type Separator = ColonsSeparator | DotSeparator;
+type ColonsSeparator = '::';
+type DotSeparator = '.';
+export {};

package/dist/types/core/plugins/config/index.d.ts

@@ -0,0 +1,2 @@
+export type * from './strapi-admin';
+export type * from './strapi-server';

package/dist/types/core/plugins/config/strapi-admin/index.d.ts

@@ -0,0 +1,5 @@
+export interface AdminInput {
+    register: unknown;
+    bootstrap: unknown;
+    registerTrads: unknown;
+}

package/dist/types/core/plugins/config/strapi-server/config.d.ts

@@ -0,0 +1,4 @@
+export interface Config {
+    validator: () => unknown;
+    default: object | (() => object);
+}