@strapi/types 0.0.0 → 4.15.0-alpha.0

package/dist/types/core/plugins/config/strapi-server/content-types.d.ts

@@ -0,0 +1,10 @@
+import type { ContentType } from '../../../schemas';
+export interface ContentTypes {
+    /**
+     * Only the schema property is used and available
+     * See loader in packages/core/strapi/src/core/loaders/plugins/index.ts
+     *  */
+    [key: string]: {
+        schema: ContentType;
+    };
+}

package/dist/types/core/plugins/config/strapi-server/controllers.d.ts

@@ -0,0 +1,7 @@
+import type { Strapi, Common } from '../../../../..';
+export type Controller = ({ strapi }: {
+    strapi: Strapi;
+}) => Common.Controller;
+export interface Controllers {
+    [key: string]: Controller;
+}

package/dist/types/core/plugins/config/strapi-server/index.d.ts

@@ -0,0 +1,20 @@
+import type { Config } from './config';
+import type { Routes } from './routes';
+import type { ContentTypes } from './content-types';
+import type { Controllers } from './controllers';
+import type { Register, Bootstrap, Destroy } from './lifecycle';
+export interface ServerObject {
+    register: Register;
+    bootstrap: Bootstrap;
+    destroy: Destroy;
+    config: Config;
+    routes: Routes;
+    contentTypes: ContentTypes;
+    controllers: Controllers;
+    registerTrads: unknown;
+    services: unknown;
+    policies: unknown;
+    middlewares: unknown;
+}
+export type ServerFunction = () => ServerObject;
+export type ServerInput = ServerObject | ServerFunction;

package/dist/types/core/plugins/config/strapi-server/lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { Strapi } from '../../../../..';
+export type LifecycleMethod = ({ strapi }: {
+    strapi: Strapi;
+}) => Promise<unknown> | unknown;
+export type Register = LifecycleMethod;
+export type Bootstrap = LifecycleMethod;
+export type Destroy = LifecycleMethod;

package/dist/types/core/plugins/config/strapi-server/routes.d.ts

@@ -0,0 +1,10 @@
+import type { Common } from '../../..';
+export type ArrayNotation = Common.RouteInput[];
+export interface ObjectNotation {
+    routes: Common.RouteInput[];
+    type?: Common.RouterType;
+}
+export interface NamedRoutes {
+    [key: string]: ObjectNotation;
+}
+export type Routes = ArrayNotation | NamedRoutes;

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

@@ -0,0 +1,5 @@
+import type { Common, Shared, Utils } from '../..';
+export type IsEnabled<TName extends keyof any, TSchemaUID extends Common.UID.Schema> = TName extends keyof Shared.PluginActivation ? Shared.PluginActivation[TName] extends infer TRule ? Utils.Expression.Or<Utils.Expression.Not<Common.AreSchemaRegistriesExtended>, Utils.Expression.Extends<Common.Schemas[TSchemaUID]['pluginOptions'], {
+    [key in TName]: TRule;
+}>> : false : false;
+export * as Config from './config';

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/schemas/index.d.ts

@@ -0,0 +1,124 @@
+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';
+    uid: Common.UID.Component;
+    category: string;
+}

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

@@ -0,0 +1,25 @@
+export interface StrapiDirectories {
+    static: {
+        public: string;
+    };
+    app: {
+        root: string;
+        src: string;
+        api: string;
+        components: string;
+        extensions: string;
+        policies: string;
+        middlewares: string;
+        config: string;
+    };
+    dist: {
+        root: string;
+        src: string;
+        api: string;
+        components: string;
+        extensions: string;
+        policies: string;
+        middlewares: string;
+        config: string;
+    };
+}

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-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/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/router.d.ts

@@ -0,0 +1,62 @@
+import type { ExtendableContext, Middleware as KoaMiddleware } from 'koa';
+import type { Strapi } from '../..';
+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/service.d.ts

@@ -0,0 +1,64 @@
+import type { Common, Utils } from '..';
+type Entity = {
+    id: string | number;
+} & Record<string, unknown>;
+type PaginatedEntiies = {
+    results: Entity[];
+    pagination: {
+        page: number;
+        pageSize: number | null;
+        start?: undefined;
+        limit?: undefined;
+    } | {
+        start: number;
+        limit: number;
+        page?: undefined;
+        pageSize?: undefined;
+    };
+};
+type Data = Record<string, unknown>;
+/**
+ * Base Core-API service type
+ */
+export interface Base {
+    getFetchParams(params: object): object;
+}
+/**
+ * Generic core api service structure
+ */
+export type Generic = {
+    [key: keyof any]: unknown;
+};
+/**
+ * Core-API collection type service
+ */
+export interface CollectionType extends Base {
+    find(params: object): Promise<PaginatedEntiies>;
+    findOne(entityId: number | `${number}`, params: object): Promise<Entity | null>;
+    create(params: {
+        data: Data;
+        [key: string]: unknown;
+    }): Promise<Entity>;
+    update(entityId: number | `${number}`, params: {
+        data: Data;
+        [key: string]: unknown;
+    }): Promise<Entity> | Entity;
+    delete(entityId: number | `${number}`, params: object): Promise<Entity> | Entity;
+}
+/**
+ * Core-API single type service
+ */
+export interface SingleType extends Base {
+    find(params: object): Promise<Entity> | Entity;
+    createOrUpdate(params: {
+        data: Data;
+        [key: string]: unknown;
+    }): 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> = Partial<ContentType<TContentTypeUID>> & Generic;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './core';
+export type * as CoreApi from './core-api';
+export type * as Utils from './utils';
+export type * as Shared from './shared';

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

@@ -0,0 +1,3 @@
+export * from './registries';
+export * from './entity-service';
+export * from './plugins';

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

@@ -0,0 +1,37 @@
+import type { Common, Schema, UID } from '..';
+/**
+ * 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 {
+    [uid: UID.Policy]: unknown;
+}
+/**
+ * Shared middleware registry
+ */
+export interface Middlewares {
+    [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/dist/types/utils/array.d.ts

@@ -0,0 +1,15 @@
+import type { Utils } from '..';
+/**
+ * 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/dist/types/utils/expression.d.ts

@@ -0,0 +1,42 @@
+import type { Utils } from '..';
+export type True = true;
+export type False = false;
+export type BooleanValue = True | False;
+export type IsNever<TValue> = StrictEqual<TValue, never>;
+export type IsNotNever<TValue> = Not<IsNever<TValue>>;
+export type IsTrue<TValue> = [TValue] extends [True] ? True : False;
+export type IsFalse<TValue> = [TValue] extends [False] ? True : False;
+export type StrictEqual<TValue, TMatch> = And<Extends<TValue, TMatch>, Extends<TMatch, TValue>>;
+export type Extends<TLeft, TRight> = [TLeft] extends [TRight] ? True : False;
+export type DoesNotExtends<TLeft, TRight> = Not<Extends<TLeft, TRight>>;
+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 MatchAllUnion<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>, MatchAllUnion<TTail, TDefault>>, TDefault> : never : never;
+export type MatchAllIntersect<TTests extends Test[], TDefault = unknown> = TTests extends [
+    infer THead extends Test,
+    ...infer TTail extends Test[]
+] ? THead extends Test<infer TExpression, infer TValue> ? // Actual test case evaluation
+If<TExpression, TValue, TDefault> & If<Utils.Array.IsNotEmpty<TTail>, MatchAllIntersect<TTail, TDefault>, TDefault> : TDefault : TDefault;
+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> = IsTrue<IsTrue<TLeft> | IsTrue<TRight>>;
+export type Or<TLeft extends BooleanValue, TRight extends BooleanValue> = Not<IsFalse<IsTrue<TLeft> | IsTrue<TRight>>>;

package/dist/types/utils/function.d.ts

@@ -0,0 +1,2 @@
+export type Any = (...args: any[]) => any;
+export type AnyPromise = (...args: any[]) => Promise<any>;