@strapi/strapi 4.12.6 → 4.13.0-alpha.0

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;
+export type IntegerValue = number;
+export type GetIntegerValue<T extends Attribute.Attribute> = T extends Integer ? IntegerValue : never;

package/dist/types/core/attributes/integer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=integer.js.map

package/dist/types/core/attributes/integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/integer.ts"],"names":[],"mappings":""}

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;
+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/json.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=json.js.map

package/dist/types/core/attributes/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/json.ts"],"names":[],"mappings":""}

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;
+    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/media.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=media.js.map

package/dist/types/core/attributes/media.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/media.ts"],"names":[],"mappings":""}

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/password.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=password.js.map

package/dist/types/core/attributes/password.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"password.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/password.ts"],"names":[],"mappings":""}

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/relation.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=relation.js.map

package/dist/types/core/attributes/relation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/relation.ts"],"names":[],"mappings":""}

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/richtext.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=richtext.js.map

package/dist/types/core/attributes/richtext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"richtext.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/richtext.ts"],"names":[],"mappings":""}

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/string.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=string.js.map

package/dist/types/core/attributes/string.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/string.ts"],"names":[],"mappings":""}

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/text.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=text.js.map

package/dist/types/core/attributes/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/text.ts"],"names":[],"mappings":""}

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/time.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=time.js.map

package/dist/types/core/attributes/time.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/time.ts"],"names":[],"mappings":""}

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/timestamp.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=timestamp.js.map

package/dist/types/core/attributes/timestamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/timestamp.ts"],"names":[],"mappings":""}

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/uid.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=uid.js.map

package/dist/types/core/attributes/uid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/uid.ts"],"names":[],"mappings":""}

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>>;
+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>;
+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> | 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>;
+export type GetOptionalKeys<TSchemaUID extends Common.UID.Schema> = Utils.Object.KeysExcept<GetAll<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/dist/types/core/attributes/utils.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=utils.js.map

package/dist/types/core/attributes/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/types/core/attributes/utils.ts"],"names":[],"mappings":""}

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/commands/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/dist/types/core/commands/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/types/core/commands/index.ts"],"names":[],"mappings":""}

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/api.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=api.js.map

package/dist/types/core/common/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../../../../src/types/core/common/api.ts"],"names":[],"mappings":""}

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

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

package/dist/types/core/common/controller.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=controller.js.map

package/dist/types/core/common/controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../../src/types/core/common/controller.ts"],"names":[],"mappings":""}

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/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UID = void 0;
+__exportStar(require("./controller"), exports);
+__exportStar(require("./middleware"), exports);
+__exportStar(require("./policy"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./router"), exports);
+__exportStar(require("./schema"), exports);
+exports.UID = __importStar(require("./uid"));
+__exportStar(require("./plugin"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./api"), exports);
+//# sourceMappingURL=index.js.map

package/dist/types/core/common/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/types/core/common/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,+CAA6B;AAC7B,+CAA6B;AAC7B,2CAAyB;AACzB,4CAA0B;AAC1B,2CAAyB;AACzB,2CAAyB;AACzB,6CAA6B;AAC7B,2CAAyB;AACzB,2CAAyB;AACzB,wCAAsB"}

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

@@ -0,0 +1,7 @@
+import type Koa from 'koa';
+import type { Strapi } from '../../../Strapi';
+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/middleware.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=middleware.js.map

package/dist/types/core/common/middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../../../src/types/core/common/middleware.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,24 @@
+import type { Common, Schema } from '..';
+import type { Strapi } from '../../../Strapi';
+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/module.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=module.js.map

package/dist/types/core/common/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../../src/types/core/common/module.ts"],"names":[],"mappings":""}

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/plugin.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=plugin.js.map

package/dist/types/core/common/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../../../src/types/core/common/plugin.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,9 @@
+import { ExtendableContext } from 'koa';
+import type { Strapi } from '../../../Strapi';
+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/policy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=policy.js.map

package/dist/types/core/common/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","sourceRoot":"","sources":["../../../../src/types/core/common/policy.ts"],"names":[],"mappings":""}

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/router.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=router.js.map

package/dist/types/core/common/router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.js","sourceRoot":"","sources":["../../../../src/types/core/common/router.ts"],"names":[],"mappings":""}

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

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

package/dist/types/core/common/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.js.map

package/dist/types/core/common/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../../src/types/core/common/schema.ts"],"names":[],"mappings":""}

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

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

package/dist/types/core/common/service.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=service.js.map

package/dist/types/core/common/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../src/types/core/common/service.ts"],"names":[],"mappings":""}

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/common/uid.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=uid.js.map

package/dist/types/core/common/uid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uid.js","sourceRoot":"","sources":["../../../../src/types/core/common/uid.ts"],"names":[],"mappings":""}