@strapi/types 0.0.0 → 4.14.0

package/dist/modules/entity-service/params/index.d.ts

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

package/dist/modules/entity-service/params/pagination.d.ts

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

package/dist/modules/entity-service/params/populate.d.ts

@@ -0,0 +1,68 @@
+import type { Attribute, Common, Utils } from '../../../types';
+import type { Params } from '..';
+/**
+ * Wildcard notation for populate
+ *
+ * To populate all the root level relations
+ */
+export type WildcardNotation = '*';
+/**
+ * Union of all possible string representation for populate
+ *
+ * @example
+ * type A = 'image'; // ✅
+ * type B = 'image,component'; // ✅
+ * type c = '*'; // ✅
+ * type D = 'populatableField'; // ✅
+ * type E = '<random_string>'; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> = WildcardNotation | Utils.Guard.Never<Attribute.GetPopulatableKeys<TSchemaUID>, string> | `${string},${string}` | `${string}.${string}`;
+/**
+ * Array notation for populate
+ *
+ * @example
+ * type A = ['image']; // ✅
+ * type B = ['image', 'component']; // ✅
+ * type C = ['populatableField']; // ✅
+ * type D = ['<random_string>']; // ❌
+ * type E = ['*']; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Exclude<StringNotation<TSchemaUID>, WildcardNotation>[];
+type GetPopulatableKeysWithTarget<TSchemaUID extends Common.UID.Schema> = Extract<Attribute.GetPopulatableKeys<TSchemaUID>, Attribute.GetKeysWithTarget<TSchemaUID>>;
+type GetPopulatableKeysWithoutTarget<TSchemaUID extends Common.UID.Schema> = Exclude<Attribute.GetPopulatableKeys<TSchemaUID>, GetPopulatableKeysWithTarget<TSchemaUID>>;
+/**
+ * Fragment populate notation for polymorphic attributes
+ */
+export type Fragment<TMaybeTargets extends Common.UID.Schema> = {
+    on?: {
+        [TSchemaUID in TMaybeTargets]?: boolean | NestedParams<TSchemaUID>;
+    };
+};
+type PopulateClause<TSchemaUID extends Common.UID.Schema, TKeys extends Attribute.GetPopulatableKeys<TSchemaUID>> = {
+    [TKey in TKeys]?: boolean | NestedParams<Attribute.GetTarget<TSchemaUID, TKey>>;
+};
+/**
+ * Object notation for populate
+ *
+ * @example
+ * type A = { image: true }; // ✅
+ * type B = { image: { fields: ['url', 'provider'] } }; // ✅
+ * type C = { populatableField: { populate: { nestedPopulatableField: true } } }; // ✅
+ * type D = { dynamic_zone: { on: { comp_A: { fields: ['name', 'price_a'] }, comp_B: { fields: ['name', 'price_b'] } } } }; // ✅
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = [
+    GetPopulatableKeysWithTarget<TSchemaUID>,
+    GetPopulatableKeysWithoutTarget<TSchemaUID>
+] extends [
+    infer TKeysWithTarget extends Attribute.GetPopulatableKeys<TSchemaUID>,
+    infer TKeysWithoutTarget extends Attribute.GetPopulatableKeys<TSchemaUID>
+] ? Utils.Expression.If<Utils.Expression.And<Common.AreSchemaRegistriesExtended, Utils.Expression.DoesNotExtends<Common.UID.Schema, TSchemaUID>>, Utils.Expression.If<Utils.Expression.IsNotNever<TKeysWithTarget>, PopulateClause<TSchemaUID, TKeysWithTarget>> | Utils.Expression.If<Utils.Expression.IsNotNever<TKeysWithoutTarget>, {
+    [TKey in TKeysWithoutTarget]?: boolean | Fragment<Utils.Guard.Never<Attribute.GetMorphTargets<TSchemaUID, TKey>, Common.UID.Schema>> | NestedParams<Common.UID.Schema>;
+}>, {
+    [TKey in string]?: boolean | NestedParams<Common.UID.Schema>;
+} | {
+    [TKey in string]?: boolean | Fragment<Common.UID.Schema> | NestedParams<Common.UID.Schema>;
+}> : never;
+export type NestedParams<TSchemaUID extends Common.UID.Schema> = Params.Pick<TSchemaUID, 'fields' | 'filters' | 'populate' | 'sort' | 'plugin' | 'publicationState'>;
+export type Any<TSchemaUID extends Common.UID.Schema> = StringNotation<TSchemaUID> | ArrayNotation<TSchemaUID> | ObjectNotation<TSchemaUID>;
+export {};

package/dist/modules/entity-service/params/publication-state.d.ts

@@ -0,0 +1,15 @@
+import type { Common, Utils } from '../../../types';
+export type Kind = 'preview' | 'live';
+export type IsEnabled<TSchemaUID extends Common.UID.Schema> = Utils.Expression.MatchFirst<[
+    [
+        Common.UID.IsContentType<TSchemaUID>,
+        Utils.Expression.IsTrue<NonNullable<Common.Schemas[TSchemaUID]['options']>['draftAndPublish']>
+    ],
+    [
+        Utils.Expression.And<Utils.Expression.Not<Utils.Expression.Extends<TSchemaUID, Common.UID.ContentType>>, Common.UID.IsComponent<TSchemaUID>>,
+        Utils.Expression.False
+    ]
+], Utils.Expression.BooleanValue>;
+export type For<TSchemaUID extends Common.UID.Schema> = IsEnabled<TSchemaUID> extends infer TEnabled ? Utils.Expression.If<Utils.Expression.Or<Utils.Expression.IsTrue<TEnabled>, Utils.Expression.Extends<Utils.Expression.BooleanValue, TEnabled>>, {
+    publicationState?: Kind;
+}, unknown> : never;

package/dist/modules/entity-service/params/search.d.ts

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

package/dist/modules/entity-service/params/sort.d.ts

@@ -0,0 +1,84 @@
+import type { Attribute, Common, Utils } from '../../../types';
+export declare namespace OrderKind {
+    type Asc = 'asc';
+    type Desc = 'desc';
+    type Any = Asc | Desc;
+}
+/**
+ * Single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title'; // ✅
+ * type B = 'description'; // ✅
+ * type C = 'title:asc'; // ❌
+ * type D = 'title,description'; // ❌
+ */
+type SingleAttribute<TSchemaUID extends Common.UID.Schema> = 'id' | Utils.Guard.Never<string & Attribute.GetNonPopulatableKeys<TSchemaUID>, string>;
+/**
+ * Ordered single non-populatable attribute representation
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ❌
+ * type D = 'title,description'; // ❌
+ */
+type OrderedSingleAttribute<TSchemaUID extends Common.UID.Schema> = `${SingleAttribute<TSchemaUID>}:${OrderKind.Any}`;
+/**
+ * Union of all possible string representation for a sort
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description:asc'; // ✅
+ * type E = [42]; // ❌
+ * type F = { title: 'asc' }; // ❌
+ */
+export type StringNotation<TSchemaUID extends Common.UID.Schema> = SingleAttribute<TSchemaUID> | OrderedSingleAttribute<TSchemaUID> | `${string},${string}`;
+/**
+ * Array notation for a sort
+ *
+ * @example
+ * type A = ['title:asc', 'description']; // ✅
+ * type B = ['title']; // ✅
+ * type C = ['count', 'title,description:asc']; // ✅
+ * type D = { title: 'asc' }; // ❌
+ * type E = [42]; // ❌
+ * type F = 'title'; // ❌
+ */
+export type ArrayNotation<TSchemaUID extends Common.UID.Schema> = Any<TSchemaUID>[];
+/**
+ * Object notation for a sort
+ *
+ * @example
+ * type A = { title: 'asc' }; // ✅
+ * type B = { title: 'asc', description: 'desc' }; // ✅
+ * type C = { title: 'asc', author: { name: 'asc' } }; // ✅
+ * type D = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
+ * type E = ['title']; // ❌
+ * type F = 'title'; // ❌
+ */
+export type ObjectNotation<TSchemaUID extends Common.UID.Schema> = {
+    [key in SingleAttribute<TSchemaUID>]?: OrderKind.Any;
+} & {
+    [key in Attribute.GetKeysWithTarget<TSchemaUID>]?: ObjectNotation<Attribute.GetTarget<TSchemaUID, key>>;
+};
+/**
+ * Represents any notation for a sort (string, array, object)
+ *
+ * @example
+ * type A = 'title:asc'; // ✅
+ * type B = 'description:desc'; // ✅
+ * type C = 'title'; // ✅
+ * type D = 'title,description:asc'; // ✅
+ * type E = ['title:asc', 'description']; // ✅
+ * type F = ['title']; // ✅
+ * type G = ['count', 'title,description:asc']; // ✅
+ * type H = { title: 'asc' }; // ✅
+ * type I = { title: 'asc', description: 'desc' }; // ✅
+ * type J = { title: 'asc', author: { name: 'asc' } }; // ✅
+ * type K = { author: { email: 'asc', role: { name: 'desc' } } }; // ✅
+ */
+export type Any<TSchemaUID extends Common.UID.Schema> = StringNotation<TSchemaUID> | ArrayNotation<TSchemaUID> | ObjectNotation<TSchemaUID>;
+export {};

package/dist/modules/entity-service/plugin.d.ts

@@ -0,0 +1,7 @@
+import type { Common, Plugin, Utils, Shared } from '../../types';
+export type GetPluginParams<TSchemaUID extends Common.UID.Schema> = Utils.Guard.OfTypes<[
+    never,
+    undefined
+], Utils.Object.Values<{
+    [TPluginName in keyof Shared.EntityServicePluginParams]: Shared.EntityServicePluginParams[TPluginName] extends infer TParam ? Utils.Expression.If<Plugin.IsEnabled<TPluginName, TSchemaUID>, TParam> : never;
+}>, unknown>;

package/dist/modules/entity-service/result.d.ts

@@ -0,0 +1,88 @@
+import type { Attribute, Common, Utils } from '../../types';
+import type { Params } from './index';
+type Pagination = {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    total: number;
+};
+type AnyEntity = {
+    id: Params.Attribute.ID;
+} & {
+    [key: string]: any;
+};
+export type Result<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = Utils.Expression.If<Common.AreSchemaRegistriesExtended, GetValues<TSchemaUID, Utils.Guard.Never<ExtractFields<TSchemaUID, TParams['fields']>, Attribute.GetNonPopulatableKeys<TSchemaUID>>, ExtractPopulate<TSchemaUID, TParams['populate']>>, AnyEntity>;
+export type Entity<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = Utils.Expression.If<Common.AreSchemaRegistriesExtended, GetValues<TSchemaUID, Utils.Guard.Never<ExtractFields<TSchemaUID, TParams['fields']>, Attribute.GetNonPopulatableKeys<TSchemaUID>>, Utils.Guard.Never<ExtractPopulate<TSchemaUID, TParams['populate']>, Attribute.GetPopulatableKeys<TSchemaUID>>>, AnyEntity>;
+export type PartialEntity<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = Partial<Entity<TSchemaUID, TParams>>;
+export type PaginatedResult<TSchemaUID extends Common.UID.Schema, TParams extends Params.Pick<TSchemaUID, 'fields' | 'populate'> = never> = {
+    results: Entity<TSchemaUID, TParams>[];
+    pagination: Pagination;
+};
+/**
+ * Attribute.GetValues override with extended values
+ *
+ * TODO: Make it recursive for populatable fields
+ */
+export type GetValues<TSchemaUID extends Common.UID.Schema, TFields extends Attribute.GetKeys<TSchemaUID> = Attribute.GetNonPopulatableKeys<TSchemaUID>, TPopulate extends Attribute.GetKeys<TSchemaUID> = Attribute.GetPopulatableKeys<TSchemaUID>> = Utils.Expression.If<Common.AreSchemaRegistriesExtended, Utils.Guard.Never<TFields | TPopulate, Attribute.GetKeys<TSchemaUID>> extends infer TKeys extends Attribute.GetKeys<TSchemaUID> ? Attribute.GetValues<TSchemaUID, TKeys> : never, AnyEntity>;
+type ExtractFields<TSchemaUID extends Common.UID.Schema, TFields extends Params.Fields.Any<TSchemaUID> | undefined> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.Or<Utils.Expression.StrictEqual<TFields, Params.Fields.Any<TSchemaUID>>, Utils.Expression.Or<Utils.Expression.IsNever<TFields>, Utils.Expression.StrictEqual<TFields, undefined>>>,
+        never
+    ],
+    [
+        Utils.Expression.Extends<TFields, Params.Fields.StringNotation<TSchemaUID>>,
+        ParseStringFields<TSchemaUID, Utils.Cast<TFields, Params.Fields.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TFields, Params.Fields.ArrayNotation<TSchemaUID>>,
+        ParseStringFields<TSchemaUID, Utils.Cast<Utils.Array.Values<Utils.Cast<TFields, Params.Fields.ArrayNotation<TSchemaUID>>>, Params.Fields.StringNotation<TSchemaUID>>>
+    ]
+]>;
+type ParseStringFields<TSchemaUID extends Common.UID.Schema, TFields extends Params.Fields.StringNotation<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.StrictEqual<TFields, Params.Fields.WildcardNotation>,
+        Attribute.GetNonPopulatableKeys<TSchemaUID>
+    ],
+    [
+        Utils.Expression.Extends<TFields, Params.Fields.SingleAttribute<TSchemaUID>>,
+        TFields
+    ],
+    [
+        Utils.Expression.Extends<TFields, `${string},${string}`>,
+        Utils.Array.Values<Utils.String.Split<Utils.Cast<TFields, string>, ','>>
+    ]
+]>;
+type ExtractPopulate<TSchemaUID extends Common.UID.Schema, TPopulate extends Params.Populate.Any<TSchemaUID> | undefined> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.Or<Utils.Expression.StrictEqual<TPopulate, Params.Populate.Any<TSchemaUID>>, Utils.Expression.IsNever<TPopulate>>,
+        never
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, Params.Populate.StringNotation<TSchemaUID>>,
+        ParseStringPopulate<TSchemaUID, Utils.Cast<TPopulate, Params.Populate.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, Params.Populate.ArrayNotation<TSchemaUID>>,
+        ParseStringPopulate<TSchemaUID, Utils.Cast<Utils.Array.Values<Utils.Cast<TPopulate, Params.Populate.ArrayNotation<TSchemaUID>>>, Params.Populate.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, Params.Populate.ObjectNotation<TSchemaUID>>,
+        ParseStringPopulate<TSchemaUID, Utils.Cast<keyof TPopulate, Params.Populate.StringNotation<TSchemaUID>>>
+    ]
+]>;
+type ParsePopulateDotNotation<TSchemaUID extends Common.UID.Schema, TPopulate extends Params.Populate.StringNotation<TSchemaUID>> = Utils.Cast<Utils.String.Split<Utils.Cast<TPopulate, string>, '.'>[0], Attribute.GetPopulatableKeys<TSchemaUID>>;
+type ParseStringPopulate<TSchemaUID extends Common.UID.Schema, TPopulate extends Params.Populate.StringNotation<TSchemaUID>> = Utils.Expression.MatchFirst<[
+    [
+        Utils.Expression.StrictEqual<Params.Populate.WildcardNotation, TPopulate>,
+        Attribute.GetPopulatableKeys<TSchemaUID>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, `${string},${string}`>,
+        ParsePopulateDotNotation<TSchemaUID, Utils.Cast<Utils.Array.Values<Utils.String.Split<Utils.Cast<TPopulate, string>, ','>>, Params.Populate.StringNotation<TSchemaUID>>>
+    ],
+    [
+        Utils.Expression.Extends<TPopulate, `${string}.${string}`>,
+        ParsePopulateDotNotation<TSchemaUID, TPopulate>
+    ]
+], TPopulate>;
+export {};

package/dist/modules/entity-validator.d.ts

@@ -0,0 +1,18 @@
+import { Common, Shared } from '../types';
+import type * as Types from './entity-service';
+type Entity = {
+    id: ID;
+    [key: string]: unknown;
+} | null;
+type ID = {
+    id: string | number;
+};
+export interface EntityValidator {
+    validateEntityCreation: <TUID extends Common.UID.ContentType>(model: Shared.ContentTypes[TUID], data: Types.Params.Data.Input<TUID>, options?: {
+        isDraft?: boolean;
+    }) => Promise<Types.Params.Data.Input<TUID>>;
+    validateEntityUpdate: <TUID extends Common.UID.ContentType>(model: Shared.ContentTypes[TUID], data: Partial<Types.Params.Data.Input<TUID>> | undefined, options?: {
+        isDraft?: boolean;
+    }, entity?: Entity) => Promise<Types.Params.Data.Input<TUID>>;
+}
+export {};

package/dist/modules/event-hub.d.ts

@@ -0,0 +1,14 @@
+export type Subscriber = (eventName: string, ...args: any[]) => Promise<void>;
+export type Listener = (...args: any[]) => Promise<void>;
+export interface EventHub {
+    emit(eventName: string, ...args: unknown[]): Promise<void>;
+    subscribe(subscriber: Subscriber): () => void;
+    unsubscribe(subscriber: Subscriber): void;
+    on(eventName: string, listener: Listener): () => void;
+    off(eventName: string, listener: Listener): void;
+    once(eventName: string, listener: Listener): () => void;
+    destroy(): EventHub;
+    removeListener(eventName: string, listener: Listener): void;
+    removeAllListeners(): EventHub;
+    addListener(eventName: string, listener: Listener): () => void;
+}

package/dist/modules/fetch.d.ts

@@ -0,0 +1,6 @@
+import type { RequestInit, Response } from 'node-fetch';
+import type { HttpsProxyAgent } from 'https-proxy-agent';
+export interface Fetch {
+    (url: string, options: RequestInit): Promise<Response>;
+    agent?: HttpsProxyAgent;
+}

package/dist/modules/metrics.d.ts

@@ -0,0 +1,7 @@
+export interface TelemetryService {
+    isDisabled: boolean;
+    register(): void;
+    bootstrap(): void;
+    destroy(): void;
+    send(event: string, payload?: Record<string, unknown>): Promise<boolean>;
+}

package/dist/modules/request-context.d.ts

@@ -0,0 +1,5 @@
+import type { ParameterizedContext } from 'koa';
+export interface RequestContext {
+    get(): ParameterizedContext | undefined;
+    run(store: ParameterizedContext, cb: () => Promise<void>): Promise<void>;
+}

package/dist/modules/sanitizers.d.ts

@@ -0,0 +1,8 @@
+type Sanitizer = (value: unknown) => unknown;
+export interface SanitizersRegistry {
+    get(path: string): Sanitizer[];
+    add(path: string, sanitizer: Sanitizer): this;
+    set(path: string, value?: Sanitizer[]): this;
+    has(path: string): boolean;
+}
+export {};

package/dist/modules/server.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+/// <reference types="koa__router" />
+import type * as http from 'http';
+import type Router from '@koa/router';
+import type Koa from 'koa';
+import type { Common } from '../types';
+export interface HTTPServer extends http.Server {
+    destroy: () => Promise<void>;
+}
+export interface API {
+    listRoutes(): Router.Layer[];
+    use(fn: Router.Middleware): API;
+    routes(routes: Common.Router | Omit<Common.Route, 'info'>[]): this;
+    mount(router: Router): this;
+}
+export interface Server {
+    app: Koa;
+    router: Router;
+    httpServer: HTTPServer;
+    api(name: 'content-api'): API;
+    api(name: 'admin'): API;
+    use(...args: Parameters<Koa['use']>): Server;
+    routes(routes: Common.Router | Omit<Common.Route, 'info'>[]): this;
+    mount(): this;
+    initRouting(): this;
+    initMiddlewares(): Promise<this>;
+    listRoutes(): Router.Layer[];
+    listen: HTTPServer['listen'];
+    destroy(): Promise<void>;
+}

package/dist/modules/validators.d.ts

@@ -0,0 +1,8 @@
+type Validator = unknown;
+export interface ValidatorsRegistry {
+    get(path: string): Validator[];
+    add(path: string, validator: Validator): this;
+    set(path: string, value?: Validator[]): this;
+    has(path: string): boolean;
+}
+export {};

package/dist/modules/webhook-runner.d.ts

@@ -0,0 +1,15 @@
+import type { Webhook } from './webhook-store';
+interface Event {
+    event: string;
+    info: Record<string, unknown>;
+}
+export interface WebhookRunner {
+    deleteListener(event: string): void;
+    createListener(event: string): void;
+    executeListener({ event, info }: Event): Promise<void>;
+    run(webhook: Webhook, event: string, info?: Record<string, unknown>): Promise<unknown>;
+    add(webhook: Webhook): void;
+    update(webhook: Webhook): void;
+    remove(webhook: Webhook): void;
+}
+export {};

package/dist/modules/webhook-store.d.ts

@@ -0,0 +1,20 @@
+export interface Webhook {
+    id: string;
+    name: string;
+    url: string;
+    headers: Record<string, string>;
+    events: string[];
+    isEnabled: boolean;
+}
+export interface WebhookStore {
+    allowedEvents: Map<string, string>;
+    addAllowedEvent(key: string, value: string): void;
+    removeAllowedEvent(key: string): void;
+    listAllowedEvents(): string[];
+    getAllowedEvent(key: string): string | undefined;
+    findWebhooks(): Promise<Webhook[]>;
+    findWebhook(id: string): Promise<Webhook | null>;
+    createWebhook(data: Webhook): Promise<Webhook>;
+    updateWebhook(id: string, data: Webhook): Promise<Webhook | null>;
+    deleteWebhook(id: string): Promise<Webhook | null>;
+}

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

@@ -0,0 +1,51 @@
+/**
+ * List of all the Strapi attribute types
+ */
+export type Kind = 'string' | 'text' | 'richtext' | 'email' | 'password' | 'date' | 'time' | 'datetime' | 'timestamp' | 'integer' | 'biginteger' | 'float' | 'decimal' | 'uid' | 'enumeration' | 'boolean' | 'json' | 'media' | 'relation' | 'component' | 'dynamiczone' | 'blocks';
+/**
+ * Most basic shape of a schema attribute
+ */
+export interface Attribute<TKind extends Kind = Kind> {
+    /**
+     * Type of the attribute
+     */
+    type: TKind;
+    /**
+     * Options defined and used by the plugins
+     */
+    pluginOptions?: object;
+    useJoinTable?: boolean;
+}
+/**
+ * Creates a basic Attribute of type T
+ */
+export type OfType<T extends Kind> = Attribute<T>;
+export interface RequiredOption {
+    required?: boolean;
+}
+export interface PrivateOption {
+    private?: boolean;
+}
+export interface UniqueOption {
+    unique?: boolean;
+}
+export interface DefaultOption<T> {
+    default?: T;
+}
+export interface ConfigurableOption {
+    configurable?: boolean;
+}
+export interface MinMaxOption<T = number> {
+    min?: T;
+    max?: T;
+}
+export interface MinMaxLengthOption {
+    minLength?: number;
+    maxLength?: number;
+}
+export interface WritableOption {
+    writable?: boolean;
+}
+export interface VisibleOption {
+    visible?: boolean;
+}

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type BigInteger = Attribute.OfType<'biginteger'> & Attribute.ConfigurableOption & Attribute.DefaultOption<BigIntegerValue> & Attribute.MinMaxOption<string> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption & Attribute.UniqueOption;
+export type BigIntegerValue = string;
+export type GetBigIntegerValue<T extends Attribute.Attribute> = T extends BigInteger ? BigIntegerValue : never;

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

@@ -0,0 +1,4 @@
+import type { Attribute } from '..';
+export type Blocks = Attribute.OfType<'blocks'> & Attribute.ConfigurableOption & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type BlocksValue<T extends object = object> = T;
+export type GetBlocksValue<T extends Attribute.Attribute> = T extends Blocks ? BlocksValue : never;

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

@@ -0,0 +1,6 @@
+import type { Attribute } from '..';
+type BooleanAttribute = Attribute.OfType<'boolean'> & Attribute.ConfigurableOption & Attribute.DefaultOption<BooleanValue> & Attribute.PrivateOption & Attribute.RequiredOption & Attribute.WritableOption & Attribute.VisibleOption;
+export type BooleanValue = boolean;
+export type GetBooleanValue<T extends Attribute.Attribute> = T extends BooleanAttribute ? BooleanValue : never;
+export type Boolean = BooleanAttribute;
+export {};