@strapi/strapi 4.11.0 → 4.11.1-beta.0

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

@@ -0,0 +1,167 @@
+import type * as Namespace from './namespace';
+import type * as Utils from '../utils';
+
+type StringSuffix<T extends string> = Utils.String.Suffix<T, string>;
+
+/**
+ * Template for services' unique identifier
+ */
+export type Service = StringSuffix<
+  | Namespace.WithSeparator<Namespace.Admin>
+  | Namespace.WithSeparator<Namespace.API>
+  | Namespace.WithSeparator<Namespace.Plugin>
+>;
+
+/**
+ * Template for controllers' unique identifier
+ */
+export type Controller = StringSuffix<
+  | Namespace.WithSeparator<Namespace.Admin>
+  | Namespace.WithSeparator<Namespace.API>
+  | Namespace.WithSeparator<Namespace.Plugin>
+>;
+
+/**
+ * Template for policies' unique identifier
+ */
+export type Policy = StringSuffix<
+  | Namespace.WithSeparator<Namespace.Admin>
+  | Namespace.WithSeparator<Namespace.Strapi>
+  | Namespace.WithSeparator<Namespace.Global>
+  | Namespace.WithSeparator<Namespace.API>
+  | Namespace.WithSeparator<Namespace.Plugin>
+>;
+
+/**
+ * Template for middlewares' unique identifier
+ */
+export type Middleware = StringSuffix<
+  | Namespace.WithSeparator<Namespace.Admin>
+  | Namespace.WithSeparator<Namespace.Strapi>
+  | Namespace.WithSeparator<Namespace.Global>
+  | Namespace.WithSeparator<Namespace.API>
+  | Namespace.WithSeparator<Namespace.Plugin>
+>;
+
+/**
+ * Template for content-types' unique identifier
+ */
+export type ContentType = StringSuffix<
+  | Namespace.WithSeparator<Namespace.Admin>
+  | Namespace.WithSeparator<Namespace.Strapi>
+  | Namespace.WithSeparator<Namespace.API>
+  | Namespace.WithSeparator<Namespace.Plugin>
+>;
+
+/**
+ * Template for components' unique identifier
+ *
+ * @example
+ * 'default.foo' extends Component => true (T = 'default', N = 'foo')
+ *
+ * @example
+ * // /!\ Warning: Can cause overlap with other UID formats:
+ * // 'api::foo.bar' both extends ContentType and Component
+ * 'api::foo.bar' extends ContentType => true (N = 'api', S='::', T='foo')
+ * 'api::foo.bar' extends Component   => true (T = 'api::foo', N = 'bar')
+ */
+export type Component<
+  TCategory extends string = string,
+  TName extends string = string
+> = `${TCategory}.${TName}`;
+
+/**
+ * Represents any UID
+ */
+export type Any = Service | Controller | Policy | Middleware | ContentType | Component;
+
+/**
+ * Type representation of every UID component.
+ *
+ * The separator type is automatically inferred from the given namespace
+ */
+export interface Parsed<
+  TNamespace extends Namespace.Any = Namespace.Any,
+  TName extends string = string
+> {
+  raw: `${TNamespace}${Namespace.GetSeparator<TNamespace>}${TName}`;
+  namespace: TNamespace;
+  origin: TNamespace extends Namespace.Scoped ? Namespace.ExtractOrigin<TNamespace> : TNamespace;
+  scope: TNamespace extends Namespace.Scoped ? Namespace.ExtractScope<TNamespace> : never;
+  separator: Namespace.GetSeparator<TNamespace>;
+  name: TName;
+}
+
+/**
+ * Parse a UID literal and returns a {@link Parsed} type.
+ *
+ * Warning: Using ParseUID with a union type might produce undesired results as it'll distribute every matching namespace parsing to every union member
+ *
+ * @example
+ * type T = Parse<'admin::foo'>
+ * // ^ { namespace: 'admin'; separator: '::'; name: 'foo'; }
+ *
+ * type T = Parse<'api::foo.bar'>
+ * // ^ { namespace: 'api::foo'; separator: '.'; name: 'bar'; }
+ *
+ * type T = Parse<'admin::foo' | 'api::foo.bar'>
+ * // ^ { namespace: 'admin' | 'api::foo' ; separator: '.' | '::'; name: 'foo' | 'bar' | 'foo.bar'; }
+ */
+export type Parse<TUid extends Any> =
+  ExtractNamespace<TUid> extends infer TExtractedNamespace extends Namespace.Any
+    ? Namespace.GetSeparator<TExtractedNamespace> extends infer TSeparator extends Namespace.Separator
+      ? TUid extends `${infer TInferredNamespace extends TExtractedNamespace}${TSeparator}${infer TName extends string}`
+        ? Parsed<TInferredNamespace, TName>
+        : never
+      : never
+    : never;
+
+/**
+ * Determines if the UID's namespace matches the given one.
+ *
+ * It returns TNamespace (the {@link Namespace.Any} literal) if there is a match, never otherwise.
+ *
+ * @example
+ * type T = EnsureNamespaceMatches<'admin::foo', Namespace.Admin>
+ * // ^ Namespace.Admin
+ * @example
+ * type T = EnsureNamespaceMatches<'foo.bar', Namespace.API>
+ * // ^ never
+ * @example
+ * type T = EnsureNamespaceMatches<'api::foo.bar', Namespace.Plugin>
+ * // ^ never
+ */
+export type EnsureNamespaceMatches<
+  TUid extends Any,
+  TNamespace extends Namespace.Any
+> = TUid extends StringSuffix<Namespace.WithSeparator<TNamespace>> ? TNamespace : never;
+
+/**
+ * Get parsed properties from a given raw UID
+ */
+export type Get<TUid extends Any, TKey extends keyof Parsed> = Parse<TUid>[TKey];
+
+/**
+ * Pick parsed properties from a given raw UID
+ */
+export type Select<TUid extends Any, TKey extends keyof Parse<TUid>> = Pick<Parse<TUid>, TKey>;
+
+/**
+ * Extract the namespace literal from a given UID.
+ *
+ * @example
+ * type T = ExtractNamespace<'admin::foo'>
+ * // ^ Namespace.Admin
+ * @example
+ * type T = ExtractNamespace<'api::foo.bar'>
+ * // ^ Namespace.API
+ * @example
+ * type T = ExtractNamespace<'admin::foo' | 'api::foo.bar'>
+ * // ^ Namespace.Admin | Namespace.API
+ */
+export type ExtractNamespace<TUid extends Any> =
+  | EnsureNamespaceMatches<TUid, Namespace.Global>
+  | EnsureNamespaceMatches<TUid, Namespace.Admin>
+  | EnsureNamespaceMatches<TUid, Namespace.Strapi>
+  | EnsureNamespaceMatches<TUid, Namespace.API>
+  | EnsureNamespaceMatches<TUid, Namespace.Plugin>;

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

@@ -0,0 +1,52 @@
+import type { Common, CoreApi, Utils } from '@strapi/strapi';
+import type { ExtendableContext } from 'koa';
+
+/**
+ * Base Core-API controller type
+ *
+ * TODO: Make use of the T generic to type the other methods based on the given content type
+ */
+export interface Base {
+  // TODO: Use actual entities instead of regular object
+  transformResponse<TData, TResponse>(data: TData, meta: object): TResponse;
+  sanitizeOutput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
+  sanitizeInput<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
+  sanitizeQuery<TData>(data: TData, ctx: ExtendableContext): Promise<TData>;
+}
+
+/**
+ * Generic controller structure
+ */
+export type Generic = {
+  [name: string]: Common.ControllerHandler<unknown>;
+};
+
+/**
+ * Core-API collection type controller
+ */
+export interface CollectionType extends Base {
+  find?: Common.ControllerHandler<unknown>;
+  findOne?: Common.ControllerHandler<unknown>;
+  create?: Common.ControllerHandler<unknown>;
+  update?: Common.ControllerHandler<unknown>;
+  delete?: Common.ControllerHandler<unknown>;
+}
+
+/**
+ * Core-API single type controller
+ */
+export interface SingleType extends Base {
+  find?: Common.ControllerHandler<unknown>;
+  update?: Common.ControllerHandler<unknown>;
+  delete?: Common.ControllerHandler<unknown>;
+}
+
+export type ContentType<T extends Common.UID.ContentType> = Utils.Expression.MatchFirst<
+  [
+    Utils.Expression.Test<Common.UID.IsCollectionType<T>, CollectionType>,
+    Utils.Expression.Test<Common.UID.IsSingleType<T>, SingleType>
+  ],
+  Base
+>;
+
+export type Extendable<T extends Common.UID.ContentType> = ContentType<T> & Generic;

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

@@ -0,0 +1,3 @@
+export * as Controller from './controller';
+export * as Service from './service';
+export * as Router from './router';

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

@@ -0,0 +1,65 @@
+import type { Common, Strapi, Utils } from '@strapi/strapi';
+
+import { ExtendableContext } from 'koa';
+import { Middleware as KoaMiddleware } from 'koa';
+
+export type MiddlewareFactory = (config: any, ctx: { strapi: Strapi }) => Middleware | null;
+
+export type Middleware = KoaMiddleware | MiddlewareFactory;
+
+export interface PolicyContext extends ExtendableContext {
+  type: string;
+}
+
+export type PolicyImplementation<TCfg = unknown> = (
+  ctx: PolicyContext,
+  cfg: TCfg,
+  { strapi }: { strapi: Strapi }
+) => boolean | undefined;
+
+type HandlerConfig = {
+  auth?: false | { scope: string[] };
+  policies?: Array<string | PolicyImplementation | { name: string; config: object }>;
+  middlewares?: Array<string | Middleware | { name: string; config: object }>;
+};
+
+export type Generic = {
+  [method: string | number | symbol]: HandlerConfig;
+};
+
+export interface SingleTypeRouterConfig extends Generic {
+  find?: HandlerConfig;
+  update?: HandlerConfig;
+  delete?: HandlerConfig;
+}
+
+export interface CollectionTypeRouterConfig extends Generic {
+  find?: HandlerConfig;
+  findOne?: HandlerConfig;
+  create?: HandlerConfig;
+  update?: HandlerConfig;
+  delete?: HandlerConfig;
+}
+
+export type RouterConfig<TContentTypeUID extends Common.UID.ContentType> = {
+  prefix?: string;
+  // TODO Refactor when we have a controller registry
+  only?: string[];
+  except?: string[];
+  config: Utils.Expression.MatchFirst<
+    [
+      Utils.Expression.Test<Common.UID.IsCollectionType<TContentTypeUID>, CollectionTypeRouterConfig>,
+      Utils.Expression.Test<Common.UID.IsSingleType<TContentTypeUID>, SingleTypeRouterConfig>
+    ],
+    Generic
+  >;
+};
+
+export type Route = {
+  method: string;
+  path: string;
+};
+export type Router = {
+  prefix: string;
+  routes: Route[];
+};

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

@@ -0,0 +1,48 @@
+import type { Common, Utils } from '@strapi/strapi';
+
+// TODO Use actual entities instead of regular object
+type Entity = object;
+
+/**
+ * Base Core-API service type
+ */
+export interface Base {
+  getFetchParams?(params: object): object;
+}
+
+/**
+ * Generic service structure
+ */
+export type Generic = {
+  [method: string | number | symbol]: (...args: any) => any;
+};
+
+/**
+ * Core-API collection type service
+ */
+export interface CollectionType extends Base {
+  find?(params: object): Promise<Entity[]> | Entity;
+  findOne?(entityId: string, params: object): Promise<Entity> | Entity;
+  create?(params: object): Promise<Entity> | Entity;
+  update?(entityId: string, params: object): Promise<Entity> | Entity;
+  delete?(entityId: string, params: object): Promise<Entity> | Entity;
+}
+
+/**
+ * Core-API single type service
+ */
+export interface SingleType extends Base {
+  find?(params: object): Promise<Entity> | Entity;
+  createOrUpdate?(params: object): Promise<Entity> | Entity;
+  delete?(params: object): Promise<Entity> | Entity;
+}
+
+export type ContentType<TContentTypeUID extends Common.UID.ContentType> = Utils.Expression.MatchFirst<
+  [
+    Utils.Expression.Test<Common.UID.IsCollectionType<TContentTypeUID>, CollectionType>,
+    Utils.Expression.Test<Common.UID.IsSingleType<TContentTypeUID>, SingleType>
+  ],
+  Base
+>;
+
+export type Extendable<TContentTypeUID extends Common.UID.ContentType> = ContentType<TContentTypeUID> & Generic;

package/lib/types/index.d.ts

@@ -1,4 +1,6 @@
+// Exports from core should already be modules
 export * from './core';
 
-export * as utils from './utils';
-export * as factories from './factories';
+export * as CoreApi from './core-api';
+export * as Utils from './utils';
+export * as Shared from './shared';

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

@@ -0,0 +1 @@
+export * from './registries';

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

@@ -0,0 +1,45 @@
+import type { Common, Schema, UID } from '@strapi/strapi';
+
+/**
+ * Shared service registry
+ */
+export interface Services {
+  [uid: UID.Service]: Common.Service;
+}
+
+/**
+ * Shared controller registry
+ */
+export interface Controllers {
+  [uid: UID.Controller]: Common.Controller;
+}
+
+/**
+ * Shared policy registry
+ */
+export interface Policies {
+  // TODO: Create generic policy type
+  [uid: UID.Policy]: unknown;
+}
+
+/**
+ * Shared middleware registry
+ */
+export interface Middlewares {
+  // TODO: Create generic middleware type
+  [uid: UID.Middleware]: unknown;
+}
+
+/**
+ * Shared content-types registry
+ */
+export interface ContentTypes {
+  [key: UID.ContentType]: Schema.ContentType;
+}
+
+/**
+ * Shared component registry
+ */
+export interface Components {
+  [key: UID.Component]: Schema.Component;
+}

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

@@ -0,0 +1,25 @@
+import type { Utils } from '@strapi/strapi';
+
+/**
+ * Extract the array values into an union type
+ **/
+export type Values<TCollection extends Array<unknown>> = TCollection extends Array<infer TValues>
+  ? TValues
+  : never;
+
+/**
+ * Checks if the size of the given collection equals 0
+ */
+export type IsEmpty<TCollection extends Array<unknown>> = Utils.Expression.Extends<
+  TCollection['length'],
+  0
+>;
+
+/**
+ * Checks if the size of the given collection is not 0
+ *
+ * Returns a {@link Utils.Expression.Boolean} expression
+ */
+export type IsNotEmpty<TCollection extends Array<unknown>> = Utils.Expression.Not<
+  IsEmpty<TCollection>
+>;

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

@@ -0,0 +1,68 @@
+import type { Utils } from '@strapi/strapi';
+
+export type True = true;
+export type False = false;
+export type BooleanValue = True | False;
+
+export type Extends<TLeft, TRight> = [TLeft] extends [TRight] ? True : False;
+
+export type Not<TExpression extends BooleanValue> = If<TExpression, False, True>;
+
+export type If<TExpression extends BooleanValue, TOnTrue, TOnFalse = never> = [
+  TExpression
+] extends [True]
+  ? TOnTrue
+  : TOnFalse;
+
+export type MatchFirst<TTests extends Test[], TDefault = never> = TTests extends [
+  infer THead extends Test,
+  ...infer TTail extends Test[]
+]
+  ? THead extends Test<infer TExpression, infer TValue>
+    ? If<
+        TExpression,
+        TValue,
+        If<Utils.Array.IsNotEmpty<TTail>, MatchFirst<TTail, TDefault>, TDefault>
+      >
+    : never
+  : never;
+
+export type MatchAll<TTests extends Test[], TDefault = never> = TTests extends [
+  infer THead extends Test,
+  ...infer TTail extends Test[]
+]
+  ? THead extends Test<infer TExpression, infer TValue>
+    ? Utils.Guard.Never<
+        If<TExpression, TValue> | If<Utils.Array.IsNotEmpty<TTail>, MatchAll<TTail, TDefault>>,
+        TDefault
+      >
+    : never
+  : never;
+
+export type Test<TExpression extends BooleanValue = BooleanValue, TValue = unknown> = [
+  TExpression,
+  TValue
+];
+
+export type Some<TExpressions extends BooleanValue[]> = TExpressions extends [
+  infer THead extends BooleanValue,
+  ...infer TTail extends BooleanValue[]
+]
+  ? If<Utils.Array.IsNotEmpty<TTail>, Or<THead, Some<TTail>>, Or<THead, false>>
+  : never;
+
+export type Every<TExpressions extends BooleanValue[]> = TExpressions extends [
+  infer THead extends BooleanValue,
+  ...infer TTail extends BooleanValue[]
+]
+  ? If<Utils.Array.IsNotEmpty<TTail>, And<THead, Every<TTail>>, And<THead, True>>
+  : never;
+
+export type And<TLeft extends BooleanValue, TRight extends BooleanValue> = Extends<
+  Extends<TLeft, True> | Extends<TRight, True>,
+  True
+>;
+
+export type Or<TLeft extends BooleanValue, TRight extends BooleanValue> = Not<
+  Extends<Extends<TLeft, True> | Extends<TRight, True>, False>
+>;

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

@@ -0,0 +1,14 @@
+/**
+ * Assign a default value `TDefault` to `TValue` if `TValue` is of type `never`
+ *
+ * @example
+ * type X = Never<{ foo: 'bar' }, string>
+ * // { foo: 'bar' }
+ *
+ * type X = Never<never>
+ * // unknown
+ *
+ * type X = Never<never, string>
+ * // string
+ */
+export type Never<TValue, TDefault = unknown> = [TValue] extends [never] ? TDefault : TValue;

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

@@ -0,0 +1,19 @@
+export * as Array from './array';
+export * as Guard from './guard';
+export * as Object from './object';
+export * as String from './string';
+export * as Tuple from './tuple';
+export * as Expression from './expression';
+
+/**
+ * Get the type of a specific key `TKey` in `TValue`
+ *
+ * @example
+ *
+ * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'foo'>
+ * // 'bar'
+ *
+ * type X = Get<{ foo: 'bar', 'bar': 'foo' }, 'bar'>
+ * // 'foo'
+ */
+export type Get<TValue, TKey extends keyof TValue> = TValue[TKey];

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

@@ -0,0 +1,29 @@
+/**
+ * Retrieve object's (`TValue`) keys if they extends the given `TTest` type.
+ *
+ * @example
+ * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
+ * // 'foo' | 'bar'
+ *
+ * type Base = { x: 'foo' | 'bar' };
+ * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
+ * type X = KeysBy<Obj, Base>
+ * // 'foo' | 'bar'
+ */
+export type KeysBy<TValue, TTest> = {
+  [key in keyof TValue]: TValue[key] extends TTest ? key : never;
+}[keyof TValue];
+
+/**
+ * Retrieve object's (`TValue`) properties if their value extends the given `TTest` type.
+ *
+ * @example
+ * type X = KeysBy<{ foo: 'bar', bar: 'foo', foobar: 2 }, string>
+ * // { foo: 'bar', bar: 'foo' }
+ *
+ * type Base = { x: 'foo' | 'bar' };
+ * type Obj = { foo: { x: 'foo' }, bar: { x: 'bar' }, other: { x: '42' } };
+ * type X = KeysBy<Obj, Base>
+ * // { foo: { x: 'foo' }, bar: { x: 'bar' } }
+ */
+export type PickBy<TValue, TTest> = Pick<TValue, KeysBy<TValue, TTest>>;

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

@@ -0,0 +1,41 @@
+/**
+ * Alias for any literal type (useful for template string parameters)
+ */
+export type Literal = string | number | bigint | boolean;
+
+/**
+ * Used to check if a string includes a given literal
+ */
+export type Includes<T extends Literal> = `${string}${T}${string}`;
+
+/**
+ * Used to make sure the given string is not empty
+ */
+export type NonEmpty<T extends string> = T extends '' ? never : T;
+
+/**
+ * Split the given string into a tuple using the given `TSeparator` literal
+ */
+export type Split<
+  TValue extends string,
+  TSeparator extends Literal
+> = TValue extends `${infer TLeft}${TSeparator}${infer TRight}`
+  ? [TLeft, ...Split<TRight, TSeparator>]
+  : TValue extends ''
+  ? []
+  : [TValue];
+
+/**
+ * Add a literal suffix (`TSuffix`) at the end of the given string
+ */
+export type Suffix<TValue extends string, TSuffix extends Literal> = `${TValue}${TSuffix}`;
+
+/**
+ * Add a literal prefix (`TPrefix`) at the beginning of the given string
+ */
+export type Prefix<TValue extends string, TPrefix extends Literal> = `${TPrefix}${TValue}`;
+
+/**
+ * Creates a record where every key is a string and every value is `T`
+ */
+export type Dict<T> = Record<string, T>;

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

@@ -0,0 +1,13 @@
+import type { Literal } from './string';
+
+/**
+ * Aggregate the given tuple into a string, separated by the given `TSeparator` literal
+ */
+export type Join<TCollection extends unknown[], TSeparator extends Literal> = TCollection extends [
+  infer THead extends Literal,
+  ...infer TTail
+]
+  ? TTail['length'] extends 0
+    ? THead
+    : `${THead}${TSeparator}${Join<TTail, TSeparator>}`
+  : never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/strapi",
-  "version": "4.11.0",
+  "version": "4.11.1-beta.0",
   "description": "An open source headless CMS solution to create and manage your own API. It provides a powerful dashboard and features to make your life easier. Databases supported: MySQL, MariaDB, PostgreSQL, SQLite",
   "keywords": [
     "strapi",
@@ -81,19 +81,19 @@
   "dependencies": {
     "@koa/cors": "3.4.3",
     "@koa/router": "10.1.1",
-    "@strapi/admin": "4.11.0",
-    "@strapi/data-transfer": "4.11.0",
-    "@strapi/database": "4.11.0",
-    "@strapi/generate-new": "4.11.0",
-    "@strapi/generators": "4.11.0",
-    "@strapi/logger": "4.11.0",
-    "@strapi/permissions": "4.11.0",
-    "@strapi/plugin-content-manager": "4.11.0",
-    "@strapi/plugin-content-type-builder": "4.11.0",
-    "@strapi/plugin-email": "4.11.0",
-    "@strapi/plugin-upload": "4.11.0",
-    "@strapi/typescript-utils": "4.11.0",
-    "@strapi/utils": "4.11.0",
+    "@strapi/admin": "4.11.1-beta.0",
+    "@strapi/data-transfer": "4.11.1-beta.0",
+    "@strapi/database": "4.11.1-beta.0",
+    "@strapi/generate-new": "4.11.1-beta.0",
+    "@strapi/generators": "4.11.1-beta.0",
+    "@strapi/logger": "4.11.1-beta.0",
+    "@strapi/permissions": "4.11.1-beta.0",
+    "@strapi/plugin-content-manager": "4.11.1-beta.0",
+    "@strapi/plugin-content-type-builder": "4.11.1-beta.0",
+    "@strapi/plugin-email": "4.11.1-beta.0",
+    "@strapi/plugin-upload": "4.11.1-beta.0",
+    "@strapi/typescript-utils": "4.11.1-beta.0",
+    "@strapi/utils": "4.11.1-beta.0",
     "bcryptjs": "2.4.3",
     "boxen": "5.1.2",
     "chalk": "4.1.2",
@@ -131,7 +131,7 @@
     "package-json": "7.0.0",
     "qs": "6.11.1",
     "resolve-cwd": "3.0.0",
-    "semver": "7.3.8",
+    "semver": "7.5.1",
     "statuses": "2.0.1"
   },
   "devDependencies": {
@@ -142,5 +142,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "0de06a008d1dfbe67ebfee3562cc8ca0603d2255"
+  "gitHead": "30e56b8376b9cb52c39ecd1c3b7d8706688a1685"
 }

package/lib/core/registries/services.d.ts

@@ -1,7 +0,0 @@
-import { Strapi } from '../../';
-
-export type Service = {
-  [key: string]: (...args: any) => any;
-};
-
-export type ServiceFactory = ({ strapi: Strapi }) => Service;