@strapi/strapi 4.13.0-alpha.0 → 4.13.0-alpha.2

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

@@ -1,8 +0,0 @@
-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

@@ -1,38 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,77 +0,0 @@
-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

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

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

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

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

@@ -1,57 +0,0 @@
-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

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

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

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

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

@@ -1,122 +0,0 @@
-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

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

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

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

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

@@ -1,108 +0,0 @@
-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

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

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

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

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

@@ -1,44 +0,0 @@
-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

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

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

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

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

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

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

@@ -1,30 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,62 +0,0 @@
-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

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

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

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