@strapi/strapi 4.12.6 → 4.13.0-alpha.0

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

@@ -0,0 +1,8 @@
+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/index.js

@@ -0,0 +1,38 @@
+"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 __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;
+};
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registry = exports.UID = exports.Namespace = exports.Common = exports.Plugin = exports.Schema = exports.Attribute = void 0;
+exports.Attribute = __importStar(require("./attributes"));
+exports.Schema = __importStar(require("./schemas"));
+exports.Plugin = __importStar(require("./plugins"));
+__exportStar(require("./strapi"), exports);
+exports.Common = __importStar(require("./common"));
+exports.Namespace = __importStar(require("./namespace"));
+exports.UID = __importStar(require("./uid"));
+exports.Registry = __importStar(require("./registry"));
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAA0C;AAC1C,oDAAoC;AACpC,oDAAoC;AACpC,2CAAyB;AAEzB,mDAAmC;AACnC,yDAAyC;AACzC,6CAA6B;AAC7B,uDAAuC"}

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

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

package/dist/types/core/namespace.js.map

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

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

@@ -0,0 +1,57 @@
+import type * as UID from './uid';
+/**
+ * Extract valid keys from a given registry.
+ *
+ * It looks for {@link UID.Any} by default but the search can be narrowed to any UID subset using the `TUidFormat` generic.
+ *
+ * @example
+ * interface Registry {
+ *   'foo': unknown;
+ *   'default.foo': 'unknown';
+ *   'global::foo': unknown;
+ *   'api::foo.bar': unknown;
+ * }
+ *
+ * type T = Keys<Registry>;
+ * // ^ 'default.foo' | 'global::foo' | 'api::foo.bar'
+ * type T = Keys<Registry, UID.Policy>;
+ * // ^ 'global::foo' | 'api::foo.bar'
+ * type T = Keys<Registry, UID.Service>
+ * // ^ 'api::foo.bar'
+ */
+export type Keys<TRegistry, TUidFormat extends UID.Any = UID.Any> = Extract<keyof TRegistry, TUidFormat>;
+/**
+ * Performs a `TQuery` filtering operation on the given `TRegistry` registry.
+ *
+ * `TQuery` needs to be a partial representation of a {@link UID.Parsed}
+ *
+ * Note: For additional filtering, the registry keys' type can be passed as the third parameter.
+ *
+ * @example
+ * interface Registry {
+ *   'admin::foo': unknown;
+ *   'admin::bar': unknown;
+ *   'api::foo.bar': unknown;
+ *   'api::foo.baz': unknown;
+ *   'api::bar.foo': unknown;
+ *   'plugin::foo.bar': unknown;
+ * }
+ *
+ * type T = keyof WhereKeys<Registry, { namespace: Namespace.API }>;
+ * // ^ "api::foo.bar" | "api::foo.baz" | "api::bar.foo"
+ *
+ * type T = keyof WhereKeys<Registry, { name: 'bar' }>;
+ * // ^ "admin::bar" | "api::foo.bar" | "plugin::foo.bar"
+ *
+ * type T = keyof WhereKeys<Registry, { separator: '.' }>;
+ * // ^ "api::foo.bar" | "api::foo.baz" | "api::bar.foo" | 'plugin::foo.bar"
+ *
+ * type T = keyof WhereKeys<Registry, { namespace: Namespace.Plugin | Namespace.Admin }>;
+ * // ^ "plugin::foo.bar" | "admin::foo" | "admin::bar"
+ *
+ * type T = keyof WhereKeys<Registry, { namespace: Namespace.API; name: Utils.Includes<'b'> }>;
+ * // ^ "api::foo.bar" | "api::foo.baz"
+ */
+export type WhereKeys<TRegistry, TQuery extends Partial<UID.Parsed>, TUidFormat extends UID.Any = UID.Any> = {
+    [uid in Keys<TRegistry, TUidFormat> as UID.Parse<uid> extends TQuery ? uid : never]: TRegistry[uid];
+};

package/dist/types/core/registry.js

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

package/dist/types/core/registry.js.map

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

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

@@ -0,0 +1,122 @@
+import type { Attribute, Common } from '../..';
+/**
+ * Literal union type representing the possible natures of a content type
+ */
+export type ContentTypeKind = 'singleType' | 'collectionType';
+/**
+ * Literal union type representing the possible types of a model
+ */
+export type ModelType = 'contentType' | 'component';
+/**
+ * Data structure that can either represent a content type or a component
+ */
+export interface Schema {
+    /**
+     * The type of the model. Useful to discriminate content-types from component
+     */
+    modelType: ModelType;
+    /**
+     * Unique identifier of the schema
+     */
+    modelName: string;
+    /**
+     * Unique identifier of the schema
+     */
+    globalId: string;
+    /**
+     * Map of all the attributes with their name and definition
+     */
+    attributes: Attributes;
+    /**
+     * Options declared and read by the plugins
+     */
+    pluginOptions?: PluginOptions;
+    /**
+     * Options object dedicated to Strapi core features
+     */
+    options?: Options;
+    /**
+     * Custom table name for the schema
+     */
+    collectionName?: string;
+}
+/**
+ * Data structure containing naming and display information for a Schema
+ */
+export interface Info {
+    /**
+     * Default name to use in the admin panel
+     */
+    displayName: string;
+    /**
+     * Description of the model
+     */
+    description?: string;
+    /**
+     * FontAwesome (v5) icon name to use for the component's icon in the admin panel
+     */
+    icon?: string;
+}
+/**
+ * Low level data structure referencing every schema attribute and its name
+ */
+export interface Attributes {
+    [key: string]: Attribute.Any;
+}
+/**
+ * Structure containing every core schema options and their associated value
+ */
+export interface Options {
+    draftAndPublish?: boolean;
+    populateCreatorFields?: boolean;
+    comment?: string;
+    version?: string;
+}
+export interface PluginOptions {
+}
+/**
+ * Schema for a content type
+ */
+export interface ContentType extends Schema {
+    modelType: 'contentType';
+    /**
+     * Unique identifier of the schema
+     */
+    uid: Common.UID.ContentType;
+    /**
+     * Determine the type of the content type (single-type or collection-type)
+     */
+    kind: ContentTypeKind;
+    /**
+     * Informations about schema naming and display
+     */
+    info: ContentTypeInfo;
+}
+export interface ContentTypeInfo extends Info {
+    /**
+     * Singular form of the content type name
+     */
+    singularName: string;
+    /**
+     * Plural form of the collection type name
+     */
+    pluralName: string;
+}
+/**
+ * Schema for a collection type
+ */
+export interface CollectionType extends ContentType {
+    kind: 'collectionType';
+}
+/**
+ * Schema for a single type
+ */
+export interface SingleType extends ContentType {
+    kind: 'singleType';
+}
+/**
+ * Schema for a component
+ */
+export interface Component extends Schema {
+    modelType: 'component';
+}

package/dist/types/core/schemas/index.js

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

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

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

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

@@ -0,0 +1,108 @@
+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>;
+export {};

package/dist/types/core/uid.js

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

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

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

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

@@ -0,0 +1,44 @@
+import type { Context } from 'koa';
+import type { Common, Utils } from '..';
+/**
+ * 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 {
+    transformResponse<TData>(data: TData, meta?: object): unknown;
+    sanitizeOutput<TData>(data: TData, ctx: Context): Promise<unknown>;
+    sanitizeInput<TData>(data: TData, ctx: Context): Promise<unknown>;
+    sanitizeQuery(ctx: Context): Promise<Record<string, unknown>>;
+    validateInput<TData>(data: TData, ctx: Context): Promise<void>;
+    validateQuery(ctx: Context): Promise<void>;
+}
+/**
+ * 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> = Partial<ContentType<T>> & Generic;

package/dist/types/core-api/controller.js

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

package/dist/types/core-api/controller.js.map

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

package/dist/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/dist/types/core-api/index.js

@@ -0,0 +1,30 @@
+"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 __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.Router = exports.Service = exports.Controller = void 0;
+exports.Controller = __importStar(require("./controller"));
+exports.Service = __importStar(require("./service"));
+exports.Router = __importStar(require("./router"));
+//# sourceMappingURL=index.js.map

package/dist/types/core-api/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/core-api/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2DAA2C;AAC3C,qDAAqC;AACrC,mDAAmC"}

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

@@ -0,0 +1,62 @@
+import type { ExtendableContext, Middleware as KoaMiddleware } from 'koa';
+import type { Strapi } from '../../Strapi';
+import type { Common, Utils } from '..';
+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 | undefined;
+};
+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;
+    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>;
+    type: RouterType;
+};
+export type RouterType = 'admin' | 'content-api';
+export type Route = {
+    method: string;
+    path: string;
+};
+export type Router = {
+    type: RouterType;
+    prefix?: string;
+    routes: Route[] | (() => Route[]);
+};
+export {};

package/dist/types/core-api/router.js

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

package/dist/types/core-api/router.js.map

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