@ls-stack/utils 2.14.1 → 3.2.0

package/dist/parallelAsyncCalls.cjs

@@ -34,6 +34,11 @@ function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 // src/safeJson.ts
 function safeJsonStringify(value) {
   try {
@@ -43,7 +48,7 @@ function safeJsonStringify(value) {
   }
 }
 
-// src/rsResult.ts
+// src/tsResult.ts
 function okUnwrapOr() {
   return this.value;
 }
@@ -62,28 +67,40 @@ function mapOkAndErr({
 function returnResult() {
   return this;
 }
+function okOnOk(fn) {
+  if (this.ok) {
+    fn(this.value);
+  }
+  return this;
+}
+function errOnErr(fn) {
+  if (!this.ok) {
+    fn(this.error);
+  }
+  return this;
+}
 function ok(value = void 0) {
-  return {
-    ok: true,
-    error: false,
-    value,
+  const methods = {
     unwrapOrNull: okUnwrapOr,
     unwrapOr: okUnwrapOr,
     unwrap: okUnwrapOr,
     mapOk: okMap,
     mapErr: returnResult,
-    mapOkAndErr
+    mapOkAndErr,
+    ifOk: okOnOk,
+    ifErr: returnResult
+  };
+  return {
+    ok: true,
+    error: false,
+    value,
+    ...methods
   };
 }
 function err(error) {
-  return {
-    ok: false,
-    error,
+  const methods = {
     unwrapOrNull: () => null,
     unwrapOr: (defaultValue) => defaultValue,
-    errorResult() {
-      return err(error);
-    },
     unwrap: () => {
       if (error instanceof Error) {
         throw error;
@@ -92,7 +109,17 @@ function err(error) {
     },
     mapOk: returnResult,
     mapErr: errMap,
-    mapOkAndErr
+    mapOkAndErr,
+    ifOk: returnResult,
+    ifErr: errOnErr
+  };
+  return {
+    ok: false,
+    error,
+    errorResult() {
+      return err(error);
+    },
+    ...methods
   };
 }
 function unknownToResultError(error) {
@@ -132,7 +159,8 @@ var Result = {
   err,
   unknownToError: unknownToResultError,
   asyncUnwrap,
-  asyncMap
+  asyncMap,
+  getOkErr
 };
 function unknownToError(error) {
   if (error instanceof Error) return error;
@@ -149,10 +177,15 @@ function unknownToError(error) {
     cause: error
   });
 }
-
-// src/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+var typedResult = {
+  ok,
+  err,
+  get _type() {
+    throw new Error("usage as value is not allowed");
+  }
+};
+function getOkErr() {
+  return typedResult;
 }
 
 // src/parallelAsyncCalls.ts

package/dist/parallelAsyncCalls.d.cts

@@ -1,5 +1,4 @@
-import { Result } from './rsResult.cjs';
-import './safeJson.cjs';
+import { Result } from './tsResult.cjs';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {

package/dist/parallelAsyncCalls.d.ts

@@ -1,5 +1,4 @@
-import { Result } from './rsResult.js';
-import './safeJson.js';
+import { Result } from './tsResult.js';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {

package/dist/parallelAsyncCalls.js

@@ -1,15 +1,15 @@
-import {
-  sleep
-} from "./chunk-5DZT3Z5Z.js";
 import {
   Result,
   unknownToError
-} from "./chunk-KBFP7INB.js";
+} from "./chunk-J73KJABC.js";
+import {
+  sleep
+} from "./chunk-5DZT3Z5Z.js";
 import "./chunk-VAAMRG4K.js";
 import {
   invariant,
   isObject
-} from "./chunk-4UGSP3L3.js";
+} from "./chunk-3XCS7FVO.js";
 
 // src/parallelAsyncCalls.ts
 var ParallelAsyncResultCalls = class {

package/dist/testUtils.js

@@ -14,7 +14,7 @@ import {
 } from "./chunk-HTCYUMDR.js";
 import {
   isObject
-} from "./chunk-4UGSP3L3.js";
+} from "./chunk-3XCS7FVO.js";
 
 // src/testUtils.ts
 function createLoggerStore({

package/dist/time.cjs

@@ -41,11 +41,19 @@ module.exports = __toCommonJS(time_exports);
 
 // src/castValues.ts
 function castToNumber(value) {
-  return isNumeric(value) ? Number(value) : null;
+  return isFiniteNumeric(value) ? Number(value) : null;
 }
-function isNumeric(num) {
-  const str = String(num);
-  return !isNaN(str) && !isNaN(parseFloat(str));
+function isFiniteNumeric(num) {
+  switch (typeof num) {
+    case "number":
+      return num - num === 0;
+    case "string":
+      return num.trim() !== "" && Number.isFinite(+num);
+    case "bigint":
+      return Number.isFinite(Number(num));
+    default:
+      return false;
+  }
 }
 
 // src/mathUtils.ts

package/dist/time.js

@@ -15,9 +15,9 @@ import {
   getUnixSeconds,
   msToTimeString,
   parseTimeStringToMs
-} from "./chunk-RK6PT7JY.js";
+} from "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
-import "./chunk-GBFS2I67.js";
+import "./chunk-II4R3VVX.js";
 export {
   DAY_AS_MS,
   DAY_AS_SECS,

package/dist/{rsResult.cjs → tsResult.cjs}

@@ -17,23 +17,27 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/rsResult.ts
-var rsResult_exports = {};
-__export(rsResult_exports, {
+// src/tsResult.ts
+var tsResult_exports = {};
+__export(tsResult_exports, {
   Result: () => Result,
-  asyncResultify: () => asyncResultify,
-  createTypedResult: () => createTypedResult,
-  normalizeError: () => normalizeError,
+  err: () => err,
+  ok: () => ok,
   resultify: () => resultify,
-  safeJsonStringify: () => safeJsonStringify2,
   unknownToError: () => unknownToError
 });
-module.exports = __toCommonJS(rsResult_exports);
+module.exports = __toCommonJS(tsResult_exports);
 
 // src/assertions.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value && isFunction(value.then);
+}
 
 // src/safeJson.ts
 function safeJsonStringify(value) {
@@ -44,7 +48,7 @@ function safeJsonStringify(value) {
   }
 }
 
-// src/rsResult.ts
+// src/tsResult.ts
 function okUnwrapOr() {
   return this.value;
 }
@@ -63,28 +67,40 @@ function mapOkAndErr({
 function returnResult() {
   return this;
 }
+function okOnOk(fn) {
+  if (this.ok) {
+    fn(this.value);
+  }
+  return this;
+}
+function errOnErr(fn) {
+  if (!this.ok) {
+    fn(this.error);
+  }
+  return this;
+}
 function ok(value = void 0) {
-  return {
-    ok: true,
-    error: false,
-    value,
+  const methods = {
     unwrapOrNull: okUnwrapOr,
     unwrapOr: okUnwrapOr,
     unwrap: okUnwrapOr,
     mapOk: okMap,
     mapErr: returnResult,
-    mapOkAndErr
+    mapOkAndErr,
+    ifOk: okOnOk,
+    ifErr: returnResult
+  };
+  return {
+    ok: true,
+    error: false,
+    value,
+    ...methods
   };
 }
 function err(error) {
-  return {
-    ok: false,
-    error,
+  const methods = {
     unwrapOrNull: () => null,
     unwrapOr: (defaultValue) => defaultValue,
-    errorResult() {
-      return err(error);
-    },
     unwrap: () => {
       if (error instanceof Error) {
         throw error;
@@ -93,7 +109,17 @@ function err(error) {
     },
     mapOk: returnResult,
     mapErr: errMap,
-    mapOkAndErr
+    mapOkAndErr,
+    ifOk: returnResult,
+    ifErr: errOnErr
+  };
+  return {
+    ok: false,
+    error,
+    errorResult() {
+      return err(error);
+    },
+    ...methods
   };
 }
 function unknownToResultError(error) {
@@ -133,20 +159,27 @@ var Result = {
   err,
   unknownToError: unknownToResultError,
   asyncUnwrap,
-  asyncMap
+  asyncMap,
+  getOkErr
 };
 function resultify(fn, errorNormalizer) {
-  try {
-    return ok(fn());
-  } catch (error) {
-    return err(
-      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
+  if (!isFunction(fn)) {
+    return fn.then((value) => ok(value)).catch(
+      (error) => err(
+        errorNormalizer ? errorNormalizer(error) : unknownToError(error)
+      )
     );
   }
-}
-async function asyncResultify(fn, errorNormalizer) {
   try {
-    return ok(await fn());
+    const result = fn();
+    if (isPromise(result)) {
+      return result.then((value) => ok(value)).catch(
+        (error) => err(
+          errorNormalizer ? errorNormalizer(error) : unknownToError(error)
+        )
+      );
+    }
+    return ok(result);
   } catch (error) {
     return err(
       errorNormalizer ? errorNormalizer(error) : unknownToError(error)
@@ -168,23 +201,21 @@ function unknownToError(error) {
     cause: error
   });
 }
-function normalizeError(error) {
-  return unknownToError(error);
-}
-var safeJsonStringify2 = safeJsonStringify;
-function createTypedResult() {
-  return {
-    ok,
-    err
-  };
+var typedResult = {
+  ok,
+  err,
+  get _type() {
+    throw new Error("usage as value is not allowed");
+  }
+};
+function getOkErr() {
+  return typedResult;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Result,
-  asyncResultify,
-  createTypedResult,
-  normalizeError,
+  err,
+  ok,
   resultify,
-  safeJsonStringify,
   unknownToError
 });

package/dist/{rsResult.d.cts → tsResult.d.cts}

@@ -1,16 +1,15 @@
-import { safeJsonStringify as safeJsonStringify$1 } from './safeJson.cjs';
-
 type Ok<T> = {
     ok: true;
     error: false;
     value: T;
-};
+} & AnyResultMethods;
+type AnyResultMethods = Record<ResultMethodsKeys, never>;
 type ResultValidErrors = Error | Record<string, unknown> | unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
     errorResult: () => Result<any, E>;
-};
+} & AnyResultMethods;
 type ResultMethods<T, E extends ResultValidErrors> = {
     /** Returns the value if the result is Ok, otherwise returns null */
     unwrapOrNull: () => T | null;
@@ -23,13 +22,14 @@ type ResultMethods<T, E extends ResultValidErrors> = {
         ok: (value: T) => NewValue;
         err: (error: E) => NewError;
     }) => Result<NewValue, NewError>;
+    ifOk: (fn: (value: T) => void) => Result<T, E>;
+    ifErr: (fn: (error: E) => void) => Result<T, E>;
 };
-type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
-declare function ok(): OkResult<void, any>;
-declare function ok<T>(value: T): OkResult<T, any>;
-type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
-declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
-declare function unknownToResultError(error: unknown): ErrResult<Error, any>;
+type ResultMethodsKeys = keyof ResultMethods<any, any>;
+declare function ok(): Ok<void>;
+declare function ok<T>(value: T): Ok<T>;
+declare function err<E extends ResultValidErrors>(error: E): Err<E>;
+declare function unknownToResultError(error: unknown): Err<Error>;
 /** Unwraps a promise result */
 declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
 declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
@@ -62,18 +62,18 @@ declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise
  *   // result.error is an Error
  * }
  */
-type Result<T, E extends ResultValidErrors = Error> = OkResult<T, E, T> | ErrResult<E, T>;
+type Result<T, E extends ResultValidErrors = Error> = (Omit<Ok<T>, ResultMethodsKeys> | Omit<Err<E>, ResultMethodsKeys>) & ResultMethods<T, E>;
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
     unknownToError: typeof unknownToResultError;
     asyncUnwrap: typeof asyncUnwrap;
     asyncMap: typeof asyncMap;
+    getOkErr: typeof getOkErr;
 };
-/** transform a function in a result function */
-declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
-/** transform a async function in a result function */
-declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T extends Promise<any> ? never : T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<T, E>>;
 /**
  * Converts an unknown error value into an Error object.
  *
@@ -96,14 +96,25 @@ declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>
  * The original error value is preserved as the `cause` property of the returned Error.
  */
 declare function unknownToError(error: unknown): Error;
-/** @deprecated use unknownToError instead, this will be removed in the next major version */
-declare function normalizeError(error: unknown): Error;
-/** @deprecated use safeJsonStringify from `@ls-stack/utils/safeJson` instead, this will be removed in the next major version */
-declare const safeJsonStringify: typeof safeJsonStringify$1;
 type TypedResult<T, E extends ResultValidErrors = Error> = {
-    ok: (value: T) => OkResult<T, E, T>;
-    err: (error: E) => ErrResult<E, T>;
+    ok: (value: T) => Ok<T>;
+    err: (error: E) => Err<E>;
+    /**
+     * Use in combination with `typeof` to get the return type of the result
+     *
+     * @example
+     * const typedResult = createTypedResult<{ a: 'test' }>();
+     *
+     * function foo(): typeof typedResult.type {
+     *   return typedResult.ok({ a: 'test' });
+     * }
+     */
+    _type: Result<T, E>;
 };
-declare function createTypedResult<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
+type GetTypedResult<R extends Result<any, any>> = TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
+declare function getOkErr<F extends (...args: any[]) => Promise<Result<any, any>>>(): TypedResult<Awaited<ReturnType<F>> extends Result<infer T, any> ? T : never, Awaited<ReturnType<F>> extends Result<any, infer E> ? E : never>;
+declare function getOkErr<F extends (...args: any[]) => Result<any, any>>(): TypedResult<ReturnType<F> extends Result<infer T, any> ? T : never, ReturnType<F> extends Result<any, infer E> ? E : never>;
+declare function getOkErr<R extends Result<any, any>>(): TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
+declare function getOkErr<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
 
-export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify, unknownToError };
+export { type GetTypedResult, Result, type ResultValidErrors, type TypedResult, err, ok, resultify, unknownToError };

package/dist/{rsResult.d.ts → tsResult.d.ts}

@@ -1,16 +1,15 @@
-import { safeJsonStringify as safeJsonStringify$1 } from './safeJson.js';
-
 type Ok<T> = {
     ok: true;
     error: false;
     value: T;
-};
+} & AnyResultMethods;
+type AnyResultMethods = Record<ResultMethodsKeys, never>;
 type ResultValidErrors = Error | Record<string, unknown> | unknown[] | true;
 type Err<E extends ResultValidErrors> = {
     ok: false;
     error: E;
     errorResult: () => Result<any, E>;
-};
+} & AnyResultMethods;
 type ResultMethods<T, E extends ResultValidErrors> = {
     /** Returns the value if the result is Ok, otherwise returns null */
     unwrapOrNull: () => T | null;
@@ -23,13 +22,14 @@ type ResultMethods<T, E extends ResultValidErrors> = {
         ok: (value: T) => NewValue;
         err: (error: E) => NewError;
     }) => Result<NewValue, NewError>;
+    ifOk: (fn: (value: T) => void) => Result<T, E>;
+    ifErr: (fn: (error: E) => void) => Result<T, E>;
 };
-type OkResult<T, E extends ResultValidErrors, M = any> = Ok<T> & ResultMethods<M, E>;
-declare function ok(): OkResult<void, any>;
-declare function ok<T>(value: T): OkResult<T, any>;
-type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
-declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
-declare function unknownToResultError(error: unknown): ErrResult<Error, any>;
+type ResultMethodsKeys = keyof ResultMethods<any, any>;
+declare function ok(): Ok<void>;
+declare function ok<T>(value: T): Ok<T>;
+declare function err<E extends ResultValidErrors>(error: E): Err<E>;
+declare function unknownToResultError(error: unknown): Err<Error>;
 /** Unwraps a promise result */
 declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
 declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
@@ -62,18 +62,18 @@ declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise
  *   // result.error is an Error
  * }
  */
-type Result<T, E extends ResultValidErrors = Error> = OkResult<T, E, T> | ErrResult<E, T>;
+type Result<T, E extends ResultValidErrors = Error> = (Omit<Ok<T>, ResultMethodsKeys> | Omit<Err<E>, ResultMethodsKeys>) & ResultMethods<T, E>;
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
     unknownToError: typeof unknownToResultError;
     asyncUnwrap: typeof asyncUnwrap;
     asyncMap: typeof asyncMap;
+    getOkErr: typeof getOkErr;
 };
-/** transform a function in a result function */
-declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
-/** transform a async function in a result function */
-declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T extends Promise<any> ? never : T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+declare function resultify<T, E extends ResultValidErrors = Error>(fn: Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<T, E>>;
 /**
  * Converts an unknown error value into an Error object.
  *
@@ -96,14 +96,25 @@ declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>
  * The original error value is preserved as the `cause` property of the returned Error.
  */
 declare function unknownToError(error: unknown): Error;
-/** @deprecated use unknownToError instead, this will be removed in the next major version */
-declare function normalizeError(error: unknown): Error;
-/** @deprecated use safeJsonStringify from `@ls-stack/utils/safeJson` instead, this will be removed in the next major version */
-declare const safeJsonStringify: typeof safeJsonStringify$1;
 type TypedResult<T, E extends ResultValidErrors = Error> = {
-    ok: (value: T) => OkResult<T, E, T>;
-    err: (error: E) => ErrResult<E, T>;
+    ok: (value: T) => Ok<T>;
+    err: (error: E) => Err<E>;
+    /**
+     * Use in combination with `typeof` to get the return type of the result
+     *
+     * @example
+     * const typedResult = createTypedResult<{ a: 'test' }>();
+     *
+     * function foo(): typeof typedResult.type {
+     *   return typedResult.ok({ a: 'test' });
+     * }
+     */
+    _type: Result<T, E>;
 };
-declare function createTypedResult<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
+type GetTypedResult<R extends Result<any, any>> = TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
+declare function getOkErr<F extends (...args: any[]) => Promise<Result<any, any>>>(): TypedResult<Awaited<ReturnType<F>> extends Result<infer T, any> ? T : never, Awaited<ReturnType<F>> extends Result<any, infer E> ? E : never>;
+declare function getOkErr<F extends (...args: any[]) => Result<any, any>>(): TypedResult<ReturnType<F> extends Result<infer T, any> ? T : never, ReturnType<F> extends Result<any, infer E> ? E : never>;
+declare function getOkErr<R extends Result<any, any>>(): TypedResult<R extends Result<infer T, any> ? T : never, R extends Result<any, infer E> ? E : never>;
+declare function getOkErr<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
 
-export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify, unknownToError };
+export { type GetTypedResult, Result, type ResultValidErrors, type TypedResult, err, ok, resultify, unknownToError };

package/dist/tsResult.js

@@ -0,0 +1,16 @@
+import {
+  Result,
+  err,
+  ok,
+  resultify,
+  unknownToError
+} from "./chunk-J73KJABC.js";
+import "./chunk-VAAMRG4K.js";
+import "./chunk-3XCS7FVO.js";
+export {
+  Result,
+  err,
+  ok,
+  resultify,
+  unknownToError
+};

package/dist/typingTestUtils.cjs

@@ -32,10 +32,13 @@ function describe(title, func) {
 function expectType() {
   return {};
 }
+function expectTypesAre(result) {
+}
 var typingTest = {
   test,
   describe,
-  expectType
+  expectType,
+  expectTypesAre
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/typingTestUtils.d.cts

@@ -2,11 +2,37 @@ type TestTypeIsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T e
 type TestTypeNotEqual<X, Y> = true extends TestTypeIsEqual<X, Y> ? false : true;
 declare function test(title: string, func: () => any): void;
 declare function describe(title: string, func: () => any): void;
+/**
+ * Helper function for type testing that ensures a type extends `true`.
+ * Used in combination with `TestTypeIsEqual` to verify type equality at compile time.
+ *
+ * @example
+ * expectType<TestTypeIsEqual<string, string>>(); // OK
+ * expectType<TestTypeIsEqual<string, number>>(); // Type error
+ *
+ * @template T Type that must extend `true`
+ * @returns An empty object cast to type T
+ */
 declare function expectType<T extends true>(): T;
+/**
+ * Helper function for type testing that compares two types and expects a specific result.
+ * This function allows for more explicit type equality assertions with a descriptive result.
+ *
+ * @template X First type to compare
+ * @template Y Second type to compare
+ * @param result Expected comparison result: 'equal' if types are equal, 'notEqual' if they differ
+ *
+ * @example
+ * expectTypesAre<string, string>('equal'); // OK
+ * expectTypesAre<string, number>('notEqual'); // OK
+ * expectTypesAre<string, string>('notEqual'); // Type error
+ */
+declare function expectTypesAre<X, Y>(result: TestTypeIsEqual<X, Y> extends true ? 'equal' : 'notEqual'): void;
 declare const typingTest: {
     test: typeof test;
     describe: typeof describe;
     expectType: typeof expectType;
+    expectTypesAre: typeof expectTypesAre;
 };
 
 export { type TestTypeIsEqual, type TestTypeNotEqual, typingTest };