@stryke/types 0.5.1 → 0.6.0

package/README.md

@@ -44,7 +44,7 @@ This package is part of Storm Software's **🌩️ Stryke** monorepo. Stryke pac
 
 <!-- END header -->
 
-# Stryke - TypeScript Type Definitions
+# Stryke - Shared Types
 
 A package containing many base TypeScript type definitions that are shared
 across many projects.
@@ -54,19 +54,21 @@ across many projects.
 
 ## Table of Contents
 
-- [Installing](#installing)
-- [Reduced Package Size](#reduced-package-size)
-- [Development](#development)
-  - [Building](#building)
-  - [Running unit tests](#running-unit-tests)
-  - [Linting](#linting)
-- [Storm Workspaces](#storm-workspaces)
-- [Roadmap](#roadmap)
-- [Support](#support)
-- [License](#license)
-- [Changelog](#changelog)
-- [Contributing](#contributing)
-- [Contributors](#contributors)
+- [Stryke - Shared Types](#stryke---shared-types)
+  - [Table of Contents](#table-of-contents)
+  - [Installing](#installing)
+  - [Reduced Package Size](#reduced-package-size)
+  - [Development](#development)
+    - [Building](#building)
+    - [Running unit tests](#running-unit-tests)
+    - [Linting](#linting)
+  - [Storm Workspaces](#storm-workspaces)
+  - [Roadmap](#roadmap)
+  - [Support](#support)
+  - [License](#license)
+  - [Changelog](#changelog)
+  - [Contributing](#contributing)
+  - [Contributors](#contributors)
 
 <!-- END doctoc -->
 

package/dist/{utility-types/array.d.ts → array.d.ts}

@@ -1,14 +1,10 @@
 /**
  * Matches any array or array-like object.
- *
- * @category Array
  */
 export type Arrayable<T> = T | T[];
 export type UnknownArray = readonly unknown[];
 /**
  * Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
- *
- * @category Array
  */
 export type TypedArray = BigInt64Array | BigUint64Array | Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
 /**
@@ -45,8 +41,6 @@ export type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
  * ```
  *
  * @see {@link ArrayIndices}
- *
- * @category Array
  */
 export type ArrayValues<T extends readonly unknown[]> = T[number];
 /**
@@ -67,8 +61,6 @@ export type ArrayValues<T extends readonly unknown[]> = T[number];
  * ```
  *
  * @see {@link ArrayValues}
- *
- * @category Array
  */
 export type ArrayIndices<Element extends readonly unknown[]> = Exclude<Partial<Element>["length"], Element["length"]>;
 /**
@@ -100,9 +92,6 @@ export type FirstArrayElement<TArray extends UnknownArrayOrTuple> = TArray exten
  * typeof lastOf(array);
  * //=> 2
  * ```
- *
- * @category Array
- * @category Template literal
  */
 export type LastArrayElement<Elements extends readonly unknown[], ElementBeforeTailingSpreadElement = never> = Elements extends readonly [] ? ElementBeforeTailingSpreadElement : Elements extends readonly [...infer _U, infer V] ? V : Elements extends readonly [infer U, ...infer V] ? LastArrayElement<V, U> : Elements extends readonly (infer U)[] ? ElementBeforeTailingSpreadElement | U : never;
 /**
@@ -127,4 +116,3 @@ export type StaticPartOfArray<T extends UnknownArray, Result extends UnknownArra
  * ```
  */
 export type VariablePartOfArray<T extends UnknownArray> = T extends unknown ? T extends readonly [...StaticPartOfArray<T>, ...infer U] ? U : [] : never;
-export declare const filterEmpty: <T>(values?: (T | null | undefined)[]) => T[];

package/dist/{utility-types/async.d.ts → async.d.ts}

@@ -8,8 +8,6 @@ import type { FunctionLike, IsUnknown } from "./base";
  *
  * const value: Awaited<Promise<string>> = 'foo';
  * ```
- *
- * @category Async
  */
 export type Awaitable<T> = T | PromiseLike<T>;
 /**
@@ -26,8 +24,6 @@ export type Awaitable<T> = T | PromiseLike<T>;
  * type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
  * //=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
  * ```
- *
- * @category Function
  */
 export type SetReturnType<Function_ extends (...arguments_: any[]) => any, TypeToReturn> = Function_ extends (this: infer ThisArgument, ...arguments_: infer Arguments) => any ? IsUnknown<ThisArgument> extends true ? (...arguments_: Arguments) => TypeToReturn : (this: ThisArgument, ...arguments_: Arguments) => TypeToReturn : (...arguments_: Parameters<Function_>) => TypeToReturn;
 export type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
@@ -48,8 +44,6 @@ export type AsyncFunction = (...arguments_: any[]) => Promise<unknown>;
  *
  * asyncFunction().then(value => doSomething(value));
  * ```
- *
- * @category Async
  */
 export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<Target>>;
 /**
@@ -78,8 +72,6 @@ export type AsyncReturnType<Target extends AsyncFunction> = Awaited<ReturnType<T
  *   // …
  * }
  * ```
- *
- * @category Async
  */
 export type Asyncify<Function_ extends FunctionLike> = SetReturnType<Function_, Promise<Awaited<ReturnType<Function_>>>>;
 /**
@@ -97,7 +89,5 @@ export type Asyncify<Function_ extends FunctionLike> = SetReturnType<Function_,
  *
  * @param P - A promise
  * @returns [[Any]]
- *
- * @category Async
  */
-export type Await<P extends any> = P extends Promise<infer A> ? A : P;
+export type Await<P> = P extends Promise<infer A> ? A : P;

package/dist/{utility-types/base.d.ts → base.d.ts}

@@ -48,7 +48,7 @@ export type List<A = any> = ReadonlyArray<A>;
  * @param R - return type
  * @returns [[Function]]
  */
-export type FunctionLike<P extends List = any, R extends any = any> = (...args: P) => R;
+export type FunctionLike<P extends List = any, R = any> = (...args: P) => R;
 export type AnyFunction = FunctionLike<any, any>;
 export type Nullish = undefined | null;
 export type Nullishable<T> = T | Nullish;
@@ -102,8 +102,8 @@ export type Rollback = Record<string, (initialValue: any, currentValue: any) =>
 /**
  * Extract all required keys from the given type.
  *
- * @remarks This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
- * @category Utilities
+ * @remarks
+ * This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
  */
 export type RequiredKeysOf<BaseType extends object> = Exclude<{
     [Key in keyof BaseType]: BaseType extends Record<Key, BaseType[Key]> ? Key : never;
@@ -111,11 +111,11 @@ export type RequiredKeysOf<BaseType extends object> = Exclude<{
 /**
  * Returns a boolean for whether the two given types are equal.
  *
- * @remarks Use-cases: If you want to make a conditional branch based on the result of a comparison of two types.
- * @link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
- * @link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
- * @category Type Guard
- * @category Utilities
+ * @remarks
+ * Use-cases: If you want to make a conditional branch based on the result of a comparison of two types.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+ * @see https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
  */
 export type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
 export type Filter<KeyType, ExcludeType> = IsEqual<KeyType, ExcludeType> extends true ? never : KeyType extends ExcludeType ? never : KeyType;
@@ -132,10 +132,12 @@ interface ExceptOptions {
 /**
  * Create a type from an object type without certain keys.
  *
- * @remarks We recommend setting the `requireExactProps` option to `true`.
- * @remarks This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
- * @remarks This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
- * @category Object
+ * @remarks
+ * We recommend setting the `requireExactProps` option to `true`.
+ *
+ * This type is a stricter version of [`Omit`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-5.html#the-omit-helper-type). The `Omit` type does not restrict the omitted keys to be keys present on the given type, while `Except` does. The benefits of a stricter type are avoiding typos and allowing the compiler to pick up on rename refactors automatically.
+ *
+ * This type was proposed to the TypeScript team, which declined it, saying they prefer that libraries implement stricter versions of the built-in types ([microsoft/TypeScript#30825](https://github.com/microsoft/TypeScript/issues/30825#issuecomment-523668235)).
  */
 export type Except<ObjectType, KeysType extends keyof ObjectType, Options extends ExceptOptions = {
     requireExactProps: false;
@@ -145,10 +147,12 @@ export type Except<ObjectType, KeysType extends keyof ObjectType, Options extend
 /**
  * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
  *
- * @remarks Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
- * @remarks If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
- * @link https://github.com/microsoft/TypeScript/issues/15300
- * @category Object
+ * @remarks
+ * Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+ *
+ * If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/15300
  */
 export type Simplify<T> = {
     [KeyType in keyof T]: T[KeyType];
@@ -156,8 +160,8 @@ export type Simplify<T> = {
 /**
  * Create a type that makes the given keys required. The remaining keys are kept as is. The sister of the `SetOptional` type.
  *
- * @remarks Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
- * @category Object
+ * @remarks
+ * Use-case: You want to define a single model where the only thing that changes is whether or not some of the keys are required.
  */
 export type SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends unknown ? Simplify<Except<BaseType, Keys> & Required<Pick<BaseType, Keys>>> : never;
 export declare const $NestedValue: unique symbol;
@@ -222,14 +226,10 @@ export type IsFunction<T> = T extends AnyFunction ? true : false;
  *
  * (globalThis as ExtraGlobals).GLOBAL_TOKEN;
  * ```
- *
- * @category Type
  */
 export type GlobalThis = typeof globalThis;
 /**
  * Matches a [`class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
- *
- * @category Class
  */
 export interface Class<T, Arguments extends unknown[] = any[]> {
     prototype: Pick<T, keyof T>;
@@ -237,15 +237,11 @@ export interface Class<T, Arguments extends unknown[] = any[]> {
 }
 /**
  * Matches a [`class` constructor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes).
- *
- * @category Class
  */
 export type Constructor<T, Arguments extends unknown[] = any[]> = new (...arguments_: Arguments) => T;
 /**
  * Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/classes.html#abstract-classes).
  *
- * @category Class
- *
  * @privateRemarks
  * We cannot use a `type` here because TypeScript throws: 'abstract' modifier cannot appear on a type member. (1070)
  */
@@ -254,8 +250,6 @@ export interface AbstractClass<T, Arguments extends unknown[] = any[]> extends A
 }
 /**
  * Matches an [`abstract class`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-2.html#abstract-construct-signatures) constructor.
- *
- * @category Class
  */
 export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstract new (...arguments_: Arguments) => T;
 /**
@@ -263,7 +257,7 @@ export type AbstractConstructor<T, Arguments extends unknown[] = any[]> = abstra
  *
  * If `<Fill>` is not provided, it will default to `unknown`.
  *
- * @link https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
+ * @see https://itnext.io/implementing-arithmetic-within-typescripts-type-system-a1ef140a6f6f
  */
 export type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] = []> = T["length"] extends L ? T : BuildTuple<L, Fill, [...T, Fill]>;
 /**
@@ -318,8 +312,6 @@ type StructuredCloneableCollection = readonly StructuredCloneable[] | {
  * structuredClone(good);
  * //=> {number: 3, date: Date(2022-10-17 22:22:35.920), map: Map {'key' -> 1}}
  * ```
- *
- * @category Structured clone
  */
 export type StructuredCloneable = StructuredCloneablePrimitive | StructuredCloneableData | StructuredCloneableCollection;
 export {};

package/dist/index.cjs

@@ -3,47 +3,212 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-var _convert = require("./convert/index.cjs");
-Object.keys(_convert).forEach(function (key) {
+var _array = require("./array.cjs");
+Object.keys(_array).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _convert[key]) return;
+  if (key in exports && exports[key] === _array[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _convert[key];
+      return _array[key];
     }
   });
 });
-var _helpers = require("./helpers/index.cjs");
-Object.keys(_helpers).forEach(function (key) {
+var _async = require("./async.cjs");
+Object.keys(_async).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _helpers[key]) return;
+  if (key in exports && exports[key] === _async[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _helpers[key];
+      return _async[key];
     }
   });
 });
-var _typeChecks = require("./type-checks/index.cjs");
-Object.keys(_typeChecks).forEach(function (key) {
+var _base = require("./base.cjs");
+Object.keys(_base).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _typeChecks[key]) return;
+  if (key in exports && exports[key] === _base[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _typeChecks[key];
+      return _base[key];
     }
   });
 });
-var _utilityTypes = require("./utility-types/index.cjs");
-Object.keys(_utilityTypes).forEach(function (key) {
+var _configuration = require("./configuration.cjs");
+Object.keys(_configuration).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _utilityTypes[key]) return;
+  if (key in exports && exports[key] === _configuration[key]) return;
   Object.defineProperty(exports, key, {
     enumerable: true,
     get: function () {
-      return _utilityTypes[key];
+      return _configuration[key];
+    }
+  });
+});
+var _file = require("./file.cjs");
+Object.keys(_file).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _file[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _file[key];
+    }
+  });
+});
+var _form = require("./form.cjs");
+Object.keys(_form).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _form[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _form[key];
+    }
+  });
+});
+var _json = require("./json.cjs");
+Object.keys(_json).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _json[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _json[key];
+    }
+  });
+});
+var _logic = require("./logic.cjs");
+Object.keys(_logic).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _logic[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _logic[key];
+    }
+  });
+});
+var _messages = require("./messages.cjs");
+Object.keys(_messages).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _messages[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _messages[key];
+    }
+  });
+});
+var _navigator = require("./navigator.cjs");
+Object.keys(_navigator).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _navigator[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _navigator[key];
+    }
+  });
+});
+var _object = require("./object.cjs");
+Object.keys(_object).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _object[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _object[key];
+    }
+  });
+});
+var _packageJson = require("./package-json.cjs");
+Object.keys(_packageJson).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _packageJson[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _packageJson[key];
+    }
+  });
+});
+var _packageManager = require("./package-manager.cjs");
+Object.keys(_packageManager).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _packageManager[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _packageManager[key];
+    }
+  });
+});
+var _string = require("./string.cjs");
+Object.keys(_string).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _string[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _string[key];
+    }
+  });
+});
+var _system = require("./system.cjs");
+Object.keys(_system).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _system[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _system[key];
+    }
+  });
+});
+var _tsconfig = require("./tsconfig.cjs");
+Object.keys(_tsconfig).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _tsconfig[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _tsconfig[key];
+    }
+  });
+});
+var _user = require("./user.cjs");
+Object.keys(_user).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _user[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _user[key];
+    }
+  });
+});
+var _utilities = require("./utilities.cjs");
+Object.keys(_utilities).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utilities[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utilities[key];
+    }
+  });
+});
+var _validations = require("./validations.cjs");
+Object.keys(_validations).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validations[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validations[key];
     }
   });
 });

package/dist/index.d.ts

@@ -6,7 +6,22 @@
  *
  * @packageDocumentation
  */
-export * from "./convert";
-export * from "./helpers";
-export * from "./type-checks";
-export * from "./utility-types";
+export * from "./array";
+export * from "./async";
+export * from "./base";
+export * from "./configuration";
+export * from "./file";
+export * from "./form";
+export * from "./json";
+export * from "./logic";
+export * from "./messages";
+export * from "./navigator";
+export * from "./object";
+export * from "./package-json";
+export * from "./package-manager";
+export * from "./string";
+export * from "./system";
+export * from "./tsconfig";
+export * from "./user";
+export * from "./utilities";
+export * from "./validations";

package/dist/index.mjs

@@ -1 +1 @@
-export*from"./convert";export*from"./helpers";export*from"./type-checks";export*from"./utility-types";
+export*from"./array";export*from"./async";export*from"./base";export*from"./configuration";export*from"./file";export*from"./form";export*from"./json";export*from"./logic";export*from"./messages";export*from"./navigator";export*from"./object";export*from"./package-json";export*from"./package-manager";export*from"./string";export*from"./system";export*from"./tsconfig";export*from"./user";export*from"./utilities";export*from"./validations";

package/dist/{utility-types/json.d.ts → json.d.ts}

@@ -5,22 +5,16 @@ export type JsonObject = {
 };
 /**
  * Matches a JSON array.
- *
- * @category JSON
  */
 export type JsonArray = JsonValue[] | readonly JsonValue[];
 /**
  * Matches any valid JSON primitive value.
- *
- * @category JSON
  */
 export type JsonPrimitive = string | number | boolean | null;
 /**
  * Matches any valid JSON value.
  *
  * @see `Jsonify` if you need to transform a type to one that is assignable to `JsonValue`.
- *
- * @category JSON
  */
 export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
 /**
@@ -49,8 +43,6 @@ export type JsonPointerPath = (string | number)[];
  *  speed: '101'
  * };
  * ```
- *
- * @category Object
  */
 export type Stringified<ObjectType> = {
     [KeyType in keyof ObjectType]: string;
@@ -76,7 +68,5 @@ export type Stringified<ObjectType> = {
  * type StringKeysOfFoo = StringKeyOf<Foo>;
  * //=> '1' | 'stringKey'
  * ```
- *
- * @category Object
  */
 export type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;

package/dist/{utility-types/number.d.ts → number.d.ts}

@@ -7,8 +7,6 @@ export type Zero = 0 | 0n;
  * Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
  *
  * @see NegativeInfinity
- *
- * @category Numeric
  */
 export type PositiveInfinity = 1e999;
 /**
@@ -17,8 +15,6 @@ export type PositiveInfinity = 1e999;
  * Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/32277) if you want to have this type as a built-in in TypeScript.
  *
  * @see PositiveInfinity
- *
- * @category Numeric
  */
 export type NegativeInfinity = -1e999;
 /**
@@ -35,8 +31,6 @@ export type NegativeInfinity = -1e999;
  *
  * declare function setScore<T extends number>(length: Finite<T>): void;
  * ```
- *
- * @category Numeric
  */
 export type Finite<T extends number> = T extends PositiveInfinity | NegativeInfinity ? never : T;
 /**
@@ -79,8 +73,6 @@ export type Finite<T extends number> = T extends PositiveInfinity | NegativeInfi
  *
  * @see NegativeInteger
  * @see NonNegativeInteger
- *
- * @category Numeric
  */
 export type Integer<T> = T extends unknown ? IsInteger<T> extends true ? T : never : never;
 export type IsInteger<T> = T extends bigint ? true : T extends number ? number extends T ? false : T extends PositiveInfinity | NegativeInfinity ? false : Not<IsFloat<T>> : false;
@@ -100,8 +92,6 @@ export type IsFloat<T> = T extends number ? `${T}` extends `${string | number |
  * ```
  *
  * @see Integer
- *
- * @category Numeric
  */
 export type Float<T> = T extends unknown ? IsFloat<T> extends true ? T : never : never;
 /**
@@ -112,8 +102,6 @@ export type Float<T> = T extends unknown ? IsFloat<T> extends true ? T : never :
  *
  * @see Negative
  * @see Float
- *
- * @category Numeric
  */
 export type NegativeFloat<T extends number> = Negative<Float<T>>;
 /**
@@ -123,8 +111,6 @@ export type NegativeFloat<T extends number> = Negative<Float<T>>;
  *
  * @see NegativeInteger
  * @see NonNegative
- *
- * @category Numeric
  */
 export type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
 /**
@@ -137,8 +123,6 @@ export type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extend
  *
  * @see Negative
  * @see Integer
- *
- * @category Numeric
  */
 export type NegativeInteger<T extends number> = Negative<Integer<T>>;
 /**
@@ -155,8 +139,6 @@ export type NegativeInteger<T extends number> = Negative<Integer<T>>;
  *
  * declare function setLength<T extends number>(length: NonNegative<T>): void;
  * ```
- *
- * @category Numeric
  */
 export type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> extends never ? T : never;
 /**
@@ -176,8 +158,6 @@ export type NonNegative<T extends Numeric> = T extends Zero ? T : Negative<T> ex
  *
  * declare function setLength<T extends number>(length: NonNegativeInteger<T>): void;
  * ```
- *
- * @category Numeric
  */
 export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
 /**
@@ -192,7 +172,5 @@ export type NonNegativeInteger<T extends number> = NonNegative<Integer<T>>;
  * type ShouldBeFalse = IsNegative<1>;
  * type ShouldBeTrue = IsNegative<-1>;
  * ```
- *
- * @category Numeric
  */
 export type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;