@ls-stack/utils 3.63.0 → 3.66.0

package/dist/typedStrings.d.ts

@@ -1,163 +0,0 @@
-/**
- * A type representing a string that contains a specific substring. Uses
- * template literal types to ensure type safety at compile time.
- *
- * @example
- *   ```ts
- *   type EmailString = StringContaining<'@'>; // string that contains '@'
- *   const email: EmailString = 'user@example.com'; // ✓ valid
- *   ```;
- *
- * @template T - The substring that must be contained within the string
- */
-type StringContaining<T extends string> = string extends T ? never : `${string}${T}${string}`;
-/**
- * A type representing a string that starts with a specific substring. Uses
- * template literal types to ensure the string begins with the specified
- * prefix.
- *
- * @example
- *   ```ts
- *   type HttpUrl = StringStartingWith<'http'>; // string starting with 'http'
- *   const url: HttpUrl = 'https://example.com'; // ✓ valid
- *   ```;
- *
- * @template T - The substring that the string must start with
- */
-type StringStartingWith<T extends string> = string extends T ? never : `${T}${string}`;
-/**
- * A type representing a string that ends with a specific substring. Uses
- * template literal types to ensure the string ends with the specified suffix.
- *
- * @example
- *   ```ts
- *   type JavaFile = StringEndingWith<'.java'>; // string ending with '.java'
- *   const filename: JavaFile = 'HelloWorld.java'; // ✓ valid
- *   ```;
- *
- * @template T - The substring that the string must end with
- */
-type StringEndingWith<T extends string> = string extends T ? never : `${string}${T}`;
-/**
- * Type guard function that checks if a string contains a specific substring.
- * Narrows the type to `StringContaining<T>` when the check passes.
- *
- * @param str - The string to check
- * @param substring - The substring to search for
- * @returns `true` if the string contains the substring, `false` otherwise
- */
-declare function stringContains<T extends string>(str: string, substring: T): str is StringContaining<T>;
-/**
- * Type guard function that checks if a string starts with a specific substring.
- * Narrows the type to `StringStartingWith<T>` when the check passes.
- *
- * @param str - The string to check
- * @param substring - The substring to check for at the beginning
- * @returns `true` if the string starts with the substring, `false` otherwise
- */
-declare function stringStartsWith<T extends string>(str: string, substring: T): str is StringStartingWith<T>;
-/**
- * Type guard function that checks if a string ends with a specific substring.
- * Narrows the type to `StringEndingWith<T>` when the check passes.
- *
- * @param str - The string to check
- * @param substring - The substring to check for at the end
- * @returns `true` if the string ends with the substring, `false` otherwise
- */
-declare function stringEndsWith<T extends string>(str: string, substring: T): str is StringEndingWith<T>;
-/**
- * Splits a typed string by a separator that is guaranteed to exist in the
- * string. Returns an array with at least two elements: the parts before and
- * after the first separator, plus any additional parts if there are multiple
- * separators.
- *
- * @example
- *   ```ts
- *   const path: StringContaining<'/'> = 'src/utils/types.ts';
- *   const [first, second, ...rest] = splitTypedString(path, '/');
- *   // first: 'src', second: 'utils', rest: ['types.ts']
- *   ```;
- *
- * @param str - A string that contains, starts with, or ends with the separator
- * @param separator - The separator to split by
- * @returns An array with at least two string elements
- */
-declare function splitTypedString<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T): [string, string, ...string[]];
-/**
- * Splits a typed string at a specific occurrence of the separator. Unlike
- * `splitTypedString`, this returns exactly two parts: everything before the nth
- * separator and everything after it.
- *
- * @example
- *   ```ts
- *   const path: StringContaining<'.'> = 'file.name.ext';
- *   const [name, ext] = splitTypedStringAt(path, '.', 2);
- *   // name: 'file.name', ext: 'ext'
- *   ```;
- *
- * @param str - A string that contains, starts with, or ends with the separator
- * @param separator - The separator to split by
- * @param splitAtNSeparatorPos - The position of the separator to split at
- *   (1-based)
- * @returns A tuple with exactly two string elements
- */
-declare function splitTypedStringAt<T extends string>(str: StringContaining<NoInfer<T>> | StringStartingWith<NoInfer<T>> | StringEndingWith<NoInfer<T>>, separator: T, 
-/**
- * The position of the separator to split at.
- *
- * @default 1 - split at the first separator
- */
-splitAtNSeparatorPos?: number): [string, string];
-/**
- * A branded type representing a string that is guaranteed to be non-empty
- * (length > 0). This type provides compile-time safety by preventing empty
- * strings from being assigned without proper validation.
- *
- * @example
- *   ```ts
- *   function processName(name: NonEmptyString) {
- *     // name is guaranteed to be non-empty
- *     return name.toUpperCase();
- *   }
- *   ```;
- */
-type NonEmptyString = string & {
-    __nonEmptyString: true;
-};
-/**
- * Type guard function that checks if a string is non-empty. Narrows the type to
- * `NonEmptyString` when the check passes.
- *
- * @param str - The string to check
- * @returns `true` if the string has length > 0, `false` otherwise
- */
-declare function isNonEmptyString(str: string): str is NonEmptyString;
-/**
- * Converts a string to `NonEmptyString` or throws an error if the string is
- * empty. Use this when you need to ensure a string is non-empty and want to
- * fail fast.
- *
- * @param str - The string to convert
- * @returns The string as `NonEmptyString`
- * @throws Error if the string is empty
- */
-declare function asNonEmptyStringOrThrow(str: string): NonEmptyString;
-/**
- * Converts a string to `NonEmptyString` or returns `null` if the string is
- * empty. Use this when empty strings should be handled gracefully rather than
- * throwing errors.
- *
- * @param str - The string to convert
- * @returns The string as `NonEmptyString` or `null` if empty
- */
-declare function asNonEmptyStringOrNull(str: string): NonEmptyString | null;
-/**
- * Assertion function that ensures a string is non-empty. Throws an error if the
- * string is empty, otherwise narrows the type to `NonEmptyString`.
- *
- * @param str - The string to assert as non-empty
- * @throws Error if the string is empty
- */
-declare function assertStringIsNonEmpty(str: string): asserts str is NonEmptyString;
-
-export { type NonEmptyString, type StringContaining, type StringEndingWith, type StringStartingWith, asNonEmptyStringOrNull, asNonEmptyStringOrThrow, assertStringIsNonEmpty, isNonEmptyString, splitTypedString, splitTypedStringAt, stringContains, stringEndsWith, stringStartsWith };

package/dist/typedStrings.js

@@ -1,57 +0,0 @@
-// src/typedStrings.ts
-function stringContains(str, substring) {
-  return str.includes(substring);
-}
-function stringStartsWith(str, substring) {
-  return str.startsWith(substring);
-}
-function stringEndsWith(str, substring) {
-  return str.endsWith(substring);
-}
-function splitTypedString(str, separator) {
-  return str.split(separator);
-}
-function splitTypedStringAt(str, separator, splitAtNSeparatorPos = 1) {
-  const parts = str.split(separator);
-  let leftPart = parts[0];
-  let rightPart = parts.slice(1).join(separator);
-  if (leftPart === void 0) {
-    throw new Error("String does not contain the separator");
-  }
-  if (splitAtNSeparatorPos > 1) {
-    leftPart = parts.slice(0, splitAtNSeparatorPos).join(separator);
-    rightPart = parts.slice(splitAtNSeparatorPos).join(separator);
-  }
-  return [leftPart, rightPart];
-}
-function isNonEmptyString(str) {
-  return str.length > 0;
-}
-function asNonEmptyStringOrThrow(str) {
-  if (isNonEmptyString(str)) {
-    return str;
-  }
-  throw new Error("String is empty");
-}
-function asNonEmptyStringOrNull(str) {
-  if (isNonEmptyString(str)) {
-    return str;
-  }
-  return null;
-}
-function assertStringIsNonEmpty(str) {
-  if (!isNonEmptyString(str)) {
-    throw new Error("String is empty");
-  }
-}
-export {
-  asNonEmptyStringOrNull,
-  asNonEmptyStringOrThrow,
-  assertStringIsNonEmpty,
-  isNonEmptyString,
-  splitTypedString,
-  splitTypedStringAt,
-  stringContains,
-  stringEndsWith,
-  stringStartsWith
-};

package/dist/typingFnUtils.cjs

@@ -1,96 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/typingFnUtils.ts
-var typingFnUtils_exports = {};
-__export(typingFnUtils_exports, {
-  asNonPartial: () => asNonPartial,
-  asPartialUndefinedValues: () => asPartialUndefinedValues,
-  asType: () => asType,
-  isNonEmptyArray: () => isNonEmptyArray,
-  isObjKey: () => isObjKey,
-  isSubTypeOf: () => isSubTypeOf,
-  narrowStringToUnion: () => narrowStringToUnion,
-  objectHasKey: () => objectHasKey,
-  strictTypedObjectEntries: () => strictTypedObjectEntries,
-  typeOnRightExtendsLeftType: () => typeOnRightExtendsLeftType,
-  typedObjectEntries: () => typedObjectEntries,
-  typedObjectKeys: () => typedObjectKeys,
-  unionsAreTheSame: () => unionsAreTheSame
-});
-module.exports = __toCommonJS(typingFnUtils_exports);
-function asNonPartial(obj) {
-  return obj;
-}
-function typedObjectEntries(obj) {
-  return Object.entries(obj);
-}
-function strictTypedObjectEntries(obj) {
-  return Object.entries(obj);
-}
-function typedObjectKeys(obj) {
-  return Object.keys(obj);
-}
-function asType(value) {
-  return value;
-}
-function narrowStringToUnion(key, union) {
-  if (!key) return void 0;
-  if (union instanceof Set) {
-    return union.has(key) ? key : void 0;
-  }
-  if (union.includes(key)) {
-    return key;
-  }
-  return void 0;
-}
-function typeOnRightExtendsLeftType() {
-  return void 0;
-}
-var isSubTypeOf = typeOnRightExtendsLeftType;
-function isObjKey(key, obj) {
-  return typeof key === "string" && key in obj;
-}
-function unionsAreTheSame(_diff) {
-}
-function asPartialUndefinedValues(value) {
-  return value;
-}
-function isNonEmptyArray(array) {
-  return array.length > 0;
-}
-function objectHasKey(obj, key) {
-  return key in obj;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  asNonPartial,
-  asPartialUndefinedValues,
-  asType,
-  isNonEmptyArray,
-  isObjKey,
-  isSubTypeOf,
-  narrowStringToUnion,
-  objectHasKey,
-  strictTypedObjectEntries,
-  typeOnRightExtendsLeftType,
-  typedObjectEntries,
-  typedObjectKeys,
-  unionsAreTheSame
-});

package/dist/typingFnUtils.d.ts

@@ -1,100 +0,0 @@
-import { PartialPossiblyUndefinedValues } from './typeUtils.js';
-import { NonPartial } from './typingUtils.js';
-
-declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPartial<T>;
-/**
- * A wrapper to Object.entries with a better typing inference
- *
- * @param obj
- */
-declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
-    [K in keyof T]: [K, T[K]];
-}[keyof T]>[];
-/**
- * A wrapper to Object.entries with a better typing inference, but with strict
- * typing narrowing keys to strings.
- *
- * @param obj
- */
-declare function strictTypedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
-    [K in keyof T]: [K & string, T[K]];
-}[keyof T]>[];
-/**
- * A wrapper to Object.keys with a better typing inference
- *
- * @param obj
- */
-declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (keyof T)[];
-/**
- * A safe way to cast types, use to substitute the `as Type`
- *
- * @param value
- */
-declare function asType<T = unknown>(value: T): T;
-/**
- * Narrow a string to a union of strings
- *
- * @param key
- * @param union
- */
-declare function narrowStringToUnion<const T extends string>(key: string | undefined | null, union: T[] | readonly T[] | Set<T>): T | undefined;
-/**
- * Type helper to check if a type is a subtype of another type.
- *
- * @template BaseType - The base type to check against
- * @template SubType - The type that should extend BaseType
- * @returns Returns undefined, only used for type checking
- */
-declare function typeOnRightExtendsLeftType<BaseType, SubType extends BaseType>(): unknown;
-/** @deprecated Use typeOnRightExtendsLeftType instead */
-declare const isSubTypeOf: typeof typeOnRightExtendsLeftType;
-/**
- * Type helper to narrow a string to a key of an object.
- *
- * @param key
- * @param obj
- */
-declare function isObjKey<T extends Record<string, unknown>>(key: unknown, obj: T): key is keyof T;
-type UnionDiff<T, U> = [
-    T
-] extends [U] ? [
-    U
-] extends [T] ? null : {
-    onRightHasExtraErr: Exclude<U, T>;
-} : [U] extends [T] ? {
-    onRightHasMissingErr: Exclude<T, U>;
-} : {
-    onRightHasExtraErr: Exclude<U, T>;
-    onRightHasMissingErr: Exclude<T, U>;
-};
-/**
- * Type helper to compare two union types and determine their relationship.
- *
- * @template T - The first union type (left side)
- * @template U - The second union type (right side)
- * @param _diff - Null if unions are identical, or an object describing the
- *   errors
- */
-declare function unionsAreTheSame<T, U>(_diff: UnionDiff<T, U>): void;
-declare function asPartialUndefinedValues<T extends Record<string, unknown>>(value: PartialPossiblyUndefinedValues<T>): T;
-/** A type representing an array that is guaranteed to have at least one element. */
-type NonEmptyArray<T> = [T, ...T[]];
-/**
- * Type guard to check if an array has at least one element.
- *
- * @param array - The array to check
- * @returns True if the array is non-empty, false otherwise
- */
-declare function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T>;
-/**
- * Type guard to check if an object has a specific key and narrow its type.
- *
- * @param obj - The object to check
- * @param key - The key to check for
- * @returns True if the object has the key, false otherwise
- */
-declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & {
-    [K in T]: unknown;
-};
-
-export { type NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };

package/dist/typingFnUtils.js

@@ -1,30 +0,0 @@
-import {
-  asNonPartial,
-  asPartialUndefinedValues,
-  asType,
-  isNonEmptyArray,
-  isObjKey,
-  isSubTypeOf,
-  narrowStringToUnion,
-  objectHasKey,
-  strictTypedObjectEntries,
-  typeOnRightExtendsLeftType,
-  typedObjectEntries,
-  typedObjectKeys,
-  unionsAreTheSame
-} from "./chunk-GMJTLFM6.js";
-export {
-  asNonPartial,
-  asPartialUndefinedValues,
-  asType,
-  isNonEmptyArray,
-  isObjKey,
-  isSubTypeOf,
-  narrowStringToUnion,
-  objectHasKey,
-  strictTypedObjectEntries,
-  typeOnRightExtendsLeftType,
-  typedObjectEntries,
-  typedObjectKeys,
-  unionsAreTheSame
-};

package/dist/typingTestUtils.cjs

@@ -1,52 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/typingTestUtils.ts
-var typingTestUtils_exports = {};
-__export(typingTestUtils_exports, {
-  typingTest: () => typingTest
-});
-module.exports = __toCommonJS(typingTestUtils_exports);
-function test(title, func) {
-  func();
-}
-function describe(title, func) {
-  func();
-}
-function expectType() {
-  return {};
-}
-function expectTypesAre(result) {
-}
-function expectTypesAreEqual(...result) {
-}
-function expectTypesAreNotEqual(...result) {
-}
-var typingTest = {
-  test,
-  describe,
-  expectType,
-  expectTypesAre,
-  expectTypesAreEqual,
-  expectTypesAreNotEqual
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  typingTest
-});

package/dist/typingTestUtils.d.ts

@@ -1,79 +0,0 @@
-type TestTypeIsEqual<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
-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.
- *
- * @deprecated Use {@link expectTypesAreEqual} or {@link expectTypesAreNotEqual}
- *   instead
- * @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.
- *
- * @deprecated Use {@link expectTypesAreEqual} or {@link expectTypesAreNotEqual}
- *   instead
- * @example
- *   expectTypesAre<string, string>('equal'); // OK
- *   expectTypesAre<string, number>('notEqual'); // OK
- *   expectTypesAre<string, string>('notEqual'); // Type error
- *
- * @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
- */
-declare function expectTypesAre<X, Y>(result: TestTypeIsEqual<X, Y> extends true ? 'equal' : 'notEqual'): void;
-/**
- * Helper function for type testing that ensures two types are equal. If types
- * are not equal, it will show a compile-time error with details about the
- * mismatch.
- *
- * @example
- *   expectTypesAreEqual<string, string>(); // OK
- *   expectTypesAreEqual<string, number>(); // Compile error with details
- *
- * @template X First type to compare
- * @template Y Second type to compare
- * @param result Optional error parameter that appears only when types don't
- *   match
- */
-declare function expectTypesAreEqual<X, Y>(...result: TestTypeIsEqual<X, Y> extends true ? [] : [
-    error: 'type assertion failed, types should be equal but',
-    typeOnLeft: X,
-    _: 'is not equal to',
-    typeOnRight: Y
-]): void;
-/**
- * Helper function for type testing that ensures two types are not equal. If
- * types are equal, it will show a compile-time error.
- *
- * @example
- *   expectTypesAreNotEqual<string, number>(); // OK
- *   expectTypesAreNotEqual<string, string>(); // Compile error
- *
- * @template X First type to compare
- * @template Y Second type to compare
- * @param result Optional error parameter that appears only when types match
- */
-declare function expectTypesAreNotEqual<X, Y>(...result: TestTypeIsEqual<X, Y> extends false ? [] : ['error: type assertion failed, types should be NOT equal']): void;
-declare const typingTest: {
-    test: typeof test;
-    describe: typeof describe;
-    expectType: typeof expectType;
-    expectTypesAre: typeof expectTypesAre;
-    expectTypesAreEqual: typeof expectTypesAreEqual;
-    expectTypesAreNotEqual: typeof expectTypesAreNotEqual;
-};
-
-export { type TestTypeIsEqual, type TestTypeNotEqual, typingTest };

package/dist/typingTestUtils.js

@@ -1,27 +0,0 @@
-// src/typingTestUtils.ts
-function test(title, func) {
-  func();
-}
-function describe(title, func) {
-  func();
-}
-function expectType() {
-  return {};
-}
-function expectTypesAre(result) {
-}
-function expectTypesAreEqual(...result) {
-}
-function expectTypesAreNotEqual(...result) {
-}
-var typingTest = {
-  test,
-  describe,
-  expectType,
-  expectTypesAre,
-  expectTypesAreEqual,
-  expectTypesAreNotEqual
-};
-export {
-  typingTest
-};

package/dist/typingUtils.cjs

@@ -1,18 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/typingUtils.ts
-var typingUtils_exports = {};
-module.exports = __toCommonJS(typingUtils_exports);

package/dist/typingUtils.d.cts

@@ -1,35 +0,0 @@
-/** @deprecated Use `PartialRecord` from `@ls-stack/utils/typeUtils` instead */
-type PartialRecord<K extends keyof any, T> = {
-    [P in K]?: T;
-};
-/** @deprecated Use `NonPartial` from `@ls-stack/utils/typeUtils` instead */
-type NonPartial<T> = {
-    [K in keyof Required<T>]: T[K];
-};
-/**
- * @deprecated Use `ObjKeysWithValuesOfType` from `@ls-stack/utils/typeUtils`
- *   instead
- */
-type ObjKeysWithValuesOfType<Obj extends Record<PropertyKey, unknown>, ValueType> = {
-    [K in keyof Obj]: Obj[K] extends ValueType ? K : never;
-}[keyof Obj];
-/** @deprecated Use `IsAny` from `@ls-stack/utils/typeUtils` instead */
-type IsAny<T> = unknown extends T ? [
-    keyof T
-] extends [never] ? false : true : false;
-/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
-type Prettify<T extends Record<string, unknown>> = {
-    [P in keyof T]: T[P];
-} & {};
-/** @deprecated Use `DeepPrettify` from `@ls-stack/utils/typeUtils` instead */
-type DeepPrettify<T> = {
-    [K in keyof T]: T[K] extends Record<string, unknown> ? DeepPrettify<T[K]> : T[K];
-} & {};
-type AddPrefixToObjKeys<T extends Record<string, unknown>, Prefix extends string> = {
-    [K in keyof T & string as `${Prefix}${K}`]: T[K];
-};
-type AddSuffixToObjKeys<T extends Record<string, unknown>, Suffix extends string> = {
-    [K in keyof T & string as `${K}${Suffix}`]: T[K];
-};
-
-export type { AddPrefixToObjKeys, AddSuffixToObjKeys, DeepPrettify, IsAny, NonPartial, ObjKeysWithValuesOfType, PartialRecord, Prettify };