@depup/type-fest 5.5.0-depup.0 → 5.9.0-depup.0

package/source/snake-case.d.ts

@@ -16,6 +16,7 @@ import type {SnakeCase} from 'type-fest';
 const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
 const noSplitOnNumbers: SnakeCase<'p2pNetwork'> = 'p2p_network';
 const splitOnNumbers: SnakeCase<'p2pNetwork', {splitOnNumbers: true}> = 'p_2_p_network';
+const splitOnPunctuation: SnakeCase<'div.card::after', {splitOnPunctuation: true}> = 'div_card_after';
 
 // Advanced
 

package/source/snake-cased-properties-deep.d.ts

@@ -51,6 +51,13 @@ const splitOnNumbers: SnakeCasedPropertiesDeep<{line1: {line2: [{line3: string}]
 		],
 	},
 };
+
+const splitOnPunctuation: SnakeCasedPropertiesDeep<{'user@info': {'user::id': number; 'user::name': string}}, {splitOnPunctuation: true}> = {
+	'user_info': {
+		'user_id': 1,
+		'user_name': 'Tom',
+	},
+};
 ```
 
 @category Change case

package/source/snake-cased-properties.d.ts

@@ -4,7 +4,7 @@ import type {ApplyDefaultOptions} from './internal/index.d.ts';
 import type {WordsOptions} from './words.d.ts';
 
 /**
-Convert object properties to snake case but not recursively.
+Convert top-level object properties to snake case.
 
 This can be useful when, for example, converting some API types from a different style.
 
@@ -28,6 +28,10 @@ const result: SnakeCasedProperties<User> = {
 const splitOnNumbers: SnakeCasedProperties<{line1: string}, {splitOnNumbers: true}> = {
 	'line_1': 'string',
 };
+
+const splitOnPunctuation: SnakeCasedProperties<{'foo::bar': string}, {splitOnPunctuation: true}> = {
+	'foo_bar': 'string',
+};
 ```
 
 @category Change case

package/source/some-extend.d.ts

@@ -97,8 +97,8 @@ type B = SomeExtend<[1?, 2?, '3'?], string | undefined>;
 export type SomeExtend<TArray extends UnknownArray, Type, Options extends SomeExtendOptions = {}> =
 	_SomeExtend<CollapseRestElement<TArray>, Type, ApplyDefaultOptions<SomeExtendOptions, DefaultSomeExtendOptions, Options>>;
 
-type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray,
-	TArray extends readonly [infer First, ...infer Rest]
+type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<SomeExtendOptions>> = IfNotAnyOrNever<TArray, {
+	ifNot: TArray extends readonly [infer First, ...infer Rest]
 		? IsNever<First> extends true
 			? Or<Or<IsNever<Type>, IsAny<Type>>, Not<Options['strictNever']>> extends true
 				// If target `Type` is also `never`, or is `any`, or `strictNever` is disabled, return `true`.
@@ -107,7 +107,9 @@ type _SomeExtend<TArray extends UnknownArray, Type, Options extends Required<Som
 			: First extends Type
 				? true
 				: _SomeExtend<Rest, Type, Options>
-		: false,
-	false, false>;
+		: false;
+	ifAny: false;
+	ifNever: false;
+}>;
 
 export {};

package/source/split-on-rest-element.d.ts

@@ -65,10 +65,12 @@ export type SplitOnRestElement<
 	Options extends SplitOnRestElementOptions = {},
 > =
 	Array_ extends unknown // For distributing `Array_`
-		? IfNotAnyOrNever<Array_, _SplitOnRestElement<
-			Array_,
-			ApplyDefaultOptions<SplitOnRestElementOptions, DefaultSplitOnRestElementOptions, Options>
-		>> extends infer Result extends UnknownArray
+		? IfNotAnyOrNever<Array_, {
+			ifNot: _SplitOnRestElement<
+				Array_,
+				ApplyDefaultOptions<SplitOnRestElementOptions, DefaultSplitOnRestElementOptions, Options>
+			>;
+		}> extends infer Result extends UnknownArray
 			? If<IsArrayReadonly<Array_>, Readonly<Result>, Result>
 			: never // Should never happen
 		: never; // Should never happen

package/source/split.d.ts

@@ -1,6 +1,6 @@
 import type {And} from './and.d.ts';
 import type {ApplyDefaultOptions, Not} from './internal/index.d.ts';
-import type {IsStringLiteral} from './is-literal.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
 import type {Or} from './or.d.ts';
 
 /**

package/source/string-length.d.ts

@@ -0,0 +1,38 @@
+import type {StringToArray} from './string-to-array.d.ts';
+
+/**
+Returns the length of the given string.
+
+@example
+```
+import type {StringLength} from 'type-fest';
+
+type A = StringLength<'abcde'>;
+//=> 5
+
+type B = StringLength<'abcde' | 'fgh'>;
+//=> 3 | 5
+```
+
+For non-literal strings, the result is `number` because the length of a non-literal string can be any number.
+
+@example
+```
+import type {StringLength} from 'type-fest';
+
+type A = StringLength<string>;
+//=> number
+
+type B = StringLength<Uppercase<string>>;
+//=> number
+
+type C = StringLength<`${string}abc`>;
+//=> number
+```
+
+@category String
+@category Template literal
+*/
+export type StringLength<S extends string> = StringToArray<S>['length'];
+
+export {};

package/source/string-repeat.d.ts

@@ -1,5 +1,6 @@
-import type {IsNumericLiteral} from './is-literal.d.ts';
+import type {IsNumericLiteral} from './is-numeric-literal.d.ts';
 import type {IsNegative} from './numeric.d.ts';
+import type {DigitCharacter} from './characters.d.ts';
 
 /**
 Returns a new string which contains the specified number of copies of a given string, just like `String#repeat()`.
@@ -9,9 +10,9 @@ Returns a new string which contains the specified number of copies of a given st
 import type {StringRepeat} from 'type-fest';
 
 declare function stringRepeat<
-	Input extends string,
+	S extends string,
 	Count extends number,
->(input: Input, count: Count): StringRepeat<Input, Count>;
+>(input: S, count: Count): StringRepeat<S, Count>;
 
 // The return type is the exact string literal, not just `string`.
 
@@ -22,28 +23,54 @@ stringRepeat('=', 3);
 //=> '==='
 ```
 
+Note: If the specified count has a decimal part, the decimal part will be ignored.
+
+@example
+```
+import type {StringRepeat} from 'type-fest';
+
+type DecimalCount = StringRepeat<'foo', 2.5>;
+//=> 'foofoo'
+```
+
 @category String
 @category Template literal
 */
-export type StringRepeat<
-	Input extends string,
-	Count extends number,
-> = StringRepeatHelper<Input, Count>;
-
-type StringRepeatHelper<
-	Input extends string,
-	Count extends number,
-	Counter extends never[] = [],
-	Accumulator extends string = '',
-> =
-	IsNegative<Count> extends true
-		? never
-		: Input extends ''
-			? ''
-			: Count extends Counter['length']
-				? Accumulator
+export type StringRepeat<S extends string, Count extends number> =
+	Count extends unknown // To distribute `Count`
+		? IsNegative<Count> extends true
+			? never
+			: S extends ''
+				? ''
 				: IsNumericLiteral<Count> extends false
 					? string
-					: StringRepeatHelper<Input, Count, [...Counter, never], `${Accumulator}${Input}`>;
+					: `${Count}` extends `${string}e${string}`
+						? string
+						: BuildStringDigitByDigit<S, `${Count}`>
+		: never;
+
+type BuildStringDigitByDigit<S extends string, Count extends string, Accumulator extends string = ''> =
+	Count extends `${infer First extends DigitCharacter}${infer Rest}`
+		? BuildStringDigitByDigit<
+			S,
+			Rest,
+			`${RepeatStringTenTimes<Accumulator>}${DigitStringRepeat<S, First>}`
+		>
+		: Accumulator;
+
+type RepeatStringTenTimes<S extends string> = `${S}${S}${S}${S}${S}${S}${S}${S}${S}${S}`;
+
+type DigitStringRepeat<S extends string, Digit extends DigitCharacter> = [
+	'',
+	`${S}`,
+	`${S}${S}`,
+	`${S}${S}${S}`,
+	`${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}${S}`,
+	`${S}${S}${S}${S}${S}${S}${S}${S}${S}`,
+][Digit];
 
 export {};

package/source/string-slice.d.ts

@@ -1,6 +1,6 @@
 import type {Join} from './join.d.ts';
 import type {ArraySlice} from './array-slice.d.ts';
-import type {StringToArray} from './internal/index.d.ts';
+import type {StringToArray} from './string-to-array.d.ts';
 
 /**
 Returns a string slice of a given range, just like `String#slice()`.

package/source/string-to-array.d.ts

@@ -0,0 +1,97 @@
+import type {ApplyDefaultOptions} from './internal/object.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {IsStringLiteral} from './is-string-literal.d.ts';
+import type {Or} from './or.d.ts';
+
+/**
+@see {@link StringToArray}
+*/
+export type StringToArrayOptions = {
+	/**
+	When enabled, non-literal parts of the string (e.g., `string`, `Uppercase<string>`) are mapped as single elements instead of being mapped as a rest element.
+
+	Note: Enabling this option can produce misleading results that might not reflect the actual runtime behavior.
+	For example, `StringToArray<string, {mapNonLiteralsDirectly: true}>` returns `[string]`, but at runtime, the string could be `'abc'` (which satisfies `string`), and converting it to an array would result in `['a', 'b', 'c']`, which doesn't satisfy `[string]`.
+
+	So, it is recommended to not enable this option unless you are aware of the implications.
+
+	@default false
+
+	@example
+	```
+	import type {StringToArray} from 'type-fest';
+
+	type A = StringToArray<string, {mapNonLiteralsDirectly: false}>;
+	//=> string[]
+
+	type B = StringToArray<string, {mapNonLiteralsDirectly: true}>;
+	//=> [string]
+
+	type C = StringToArray<`on${string}`, {mapNonLiteralsDirectly: false}>;
+	//=> ['o', 'n', ...string[]]
+
+	type D = StringToArray<`on${string}`, {mapNonLiteralsDirectly: true}>;
+	//=> ['o', 'n', string]
+
+	type E = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: false}>;
+	//=> [...string[], 'x', 'y', 'z']
+
+	type F = StringToArray<`${string}xyz`, {mapNonLiteralsDirectly: true}>;
+	//=> [string, 'x', 'y', 'z']
+	```
+	*/
+	mapNonLiteralsDirectly?: boolean;
+};
+
+type DefaultStringToArrayOptions = {
+	mapNonLiteralsDirectly: false;
+};
+
+/**
+Returns an array of the characters of the specified string.
+
+@example
+```
+import type {StringToArray} from 'type-fest';
+
+type A = StringToArray<'abcde'>;
+//=> ['a', 'b', 'c', 'd', 'e']
+
+type B = StringToArray<''>;
+//=> []
+
+type C = StringToArray<string>;
+//=> string[]
+
+type D = StringToArray<`foo${string}bar`>;
+//=> ['f', 'o', 'o', ...string[], 'b', 'a', 'r']
+
+type E = StringToArray<`foo${string}bar`, {mapNonLiteralsDirectly: true}>;
+//=> ['f', 'o', 'o', string, 'b', 'a', 'r']
+```
+
+@see {@link StringToArrayOptions}
+
+@category String
+*/
+export type StringToArray<S extends string, Options extends StringToArrayOptions = {}> =
+	IfNotAnyOrNever<
+		S,
+		{
+			ifNot: _StringToArray<S, ApplyDefaultOptions<StringToArrayOptions, DefaultStringToArrayOptions, Options>>;
+			ifAny: unknown[];
+		}
+	>;
+
+type _StringToArray<S extends string, Options extends Required<StringToArrayOptions>, Accumulator extends string[] = []> =
+	S extends `${infer First}${infer Rest}`
+		? Or<IsStringLiteral<First>, Options['mapNonLiteralsDirectly']> extends true
+			? _StringToArray<Rest, Options, [...Accumulator, First]>
+			: _StringToArray<Rest, Options, [...Accumulator, ...First[]]>
+		: S extends ''
+			? Accumulator
+			: Options['mapNonLiteralsDirectly'] extends true
+				? [...Accumulator, S]
+				: [...Accumulator, ...S[]];
+
+export {};

package/source/string-to-number.d.ts

@@ -0,0 +1,67 @@
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
+import type {NegativeInfinity, PositiveInfinity} from './numeric.d.ts';
+
+/**
+Converts a numeric string to a number.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type PositiveInteger = StringToNumber<'1234'>;
+//=> 1234
+
+type NegativeInteger = StringToNumber<'-1234'>;
+//=> -1234
+
+type PositiveFloat = StringToNumber<'1234.56'>;
+//=> 1234.56
+
+type NegativeFloat = StringToNumber<'-1234.56'>;
+//=> -1234.56
+
+type PositiveInfinity = StringToNumber<'Infinity'>;
+//=> Infinity
+
+type NegativeInfinity = StringToNumber<'-Infinity'>;
+//=> -Infinity
+```
+
+Note: Some strings, such as `'1.50'`, `'0b10'`, or `'12_345'`, may look like they can be converted to numbers, but they don't actually have corresponding numeric literals. So, in such cases, this type produces `never`. See [type-fest#1446](https://github.com/sindresorhus/type-fest/pull/1446) for more details.
+
+@example
+```
+import type {StringToNumber} from 'type-fest';
+
+type FractionalsEndingInZero = StringToNumber<'1.50'>;
+//=> never
+
+type NonDecimalBases = StringToNumber<'0b10' | '0o10' | '0x10'>;
+//=> never
+
+type NumericSeparators = StringToNumber<'12_345'>;
+//=> never
+```
+
+@category String
+@category Numeric
+@category Template literal
+*/
+export type StringToNumber<S extends string> = IfNotAnyOrNever<S, {ifNot: _StringToNumber<S>; ifAny: number}>;
+
+type _StringToNumber<S extends string> =
+	S extends `${infer N extends number}`
+		? number extends N
+			? `${number}` extends S
+				? N
+				: never
+			: N
+		: string extends S
+			? number
+			: S extends 'Infinity'
+				? PositiveInfinity
+				: S extends '-Infinity'
+					? NegativeInfinity
+					: never;
+
+export {};

package/source/subtract.d.ts

@@ -1,7 +1,8 @@
-import type {NumberAbsolute, ReverseSign} from './internal/index.d.ts';
+import type {ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {LessThan} from './less-than.d.ts';
 import type {TupleOf} from './tuple-of.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns the difference between two numbers.
@@ -59,9 +60,9 @@ type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNeg
 		? SubtractPositives<A, B>
 		: AreNegative extends [true, true]
 			// When both numbers are negative we subtract the absolute values and then reverse the sign
-			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			? ReverseSign<SubtractPositives<Absolute<A>, Absolute<B>>>
 			// When the signs are different we can add the absolute values and then reverse the sign if A < B
-			: [...TupleOf<NumberAbsolute<A>>, ...TupleOf<NumberAbsolute<B>>] extends infer R extends unknown[]
+			: [...TupleOf<Absolute<A>>, ...TupleOf<Absolute<B>>] extends infer R extends unknown[]
 				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
 				: never;
 

package/source/sum.d.ts

@@ -1,7 +1,8 @@
 import type {TupleOf} from './tuple-of.d.ts';
-import type {NumberAbsolute, TupleMax, ReverseSign} from './internal/index.d.ts';
+import type {TupleMax, ReverseSign} from './internal/index.d.ts';
 import type {PositiveInfinity, NegativeInfinity, IsNegative} from './numeric.d.ts';
 import type {Subtract} from './subtract.d.ts';
+import type {Absolute} from './absolute.d.ts';
 
 /**
 Returns the sum of two numbers.
@@ -57,11 +58,11 @@ type SumPostChecks<A extends number, B extends number, AreNegative = [IsNegative
 		? SumPositives<A, B>
 		: AreNegative extends [true, true]
 			// When both numbers are negative we add the absolute values and then reverse the sign
-			? ReverseSign<SumPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			? ReverseSign<SumPositives<Absolute<A>, Absolute<B>>>
 			// When the signs are different we can subtract the absolute values, remove the sign
 			// and then reverse the sign if the larger absolute value is negative
-			: NumberAbsolute<Subtract<NumberAbsolute<A>, NumberAbsolute<B>>> extends infer Result extends number
-				? TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_ extends number
+			: Absolute<Subtract<Absolute<A>, Absolute<B>>> extends infer Result extends number
+				? TupleMax<[Absolute<A>, Absolute<B>]> extends infer Max_ extends number
 					? Max_ extends A | B
 						// The larger absolute value is positive, so the result is positive
 						? Result

package/source/tagged.d.ts

@@ -8,12 +8,10 @@ export type TagContainer<Token> = {
 type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
 
 /**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
+Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
 
 A type returned by `Tagged` can be passed to `Tagged` again, to create a type with multiple tags.
 
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
 A tag's name is usually a string (and must be a string, number, or symbol), but each application of a tag can also contain an arbitrary type as its "metadata". See {@link GetTagMetadata} for examples and explanation.
 
 A type `A` returned by `Tagged` is assignable to another type `B` returned by `Tagged` if and only if:
@@ -100,7 +98,7 @@ const parsed = parse(x); // The type of `parsed` is { hello: string }
 export type GetTagMetadata<Type extends Tag<TagName, unknown>, TagName extends PropertyKey> = Type[typeof tag][TagName];
 
 /**
-Revert a tagged type back to its original type by removing all tags.
+Get the untagged portion of a tagged type created with `Tagged`.
 
 Why is this necessary?
 
@@ -129,7 +127,7 @@ type WontWork = UnwrapTagged<string>;
 @category Type
 */
 export type UnwrapTagged<TaggedType extends Tag<PropertyKey, any>> =
-RemoveAllTags<TaggedType>;
+	RemoveAllTags<TaggedType>;
 
 type RemoveAllTags<T> = T extends Tag<PropertyKey, any>
 	? {

package/source/tsconfig-json.d.ts

@@ -61,6 +61,7 @@ export namespace TsConfigJson {
 			| 'ES2022'
 			| 'ES2023'
 			| 'ES2024'
+			| 'ES2025'
 			| 'ESNext'
 			// Lowercase alternatives
 			| 'es3'
@@ -76,6 +77,7 @@ export namespace TsConfigJson {
 			| 'es2022'
 			| 'es2023'
 			| 'es2024'
+			| 'es2025'
 			| 'esnext';
 
 		type Lib =
@@ -148,6 +150,13 @@ export namespace TsConfigJson {
 			| 'ES2024.Regexp'
 			| 'ES2024.SharedMemory'
 			| 'ES2024.String'
+			| 'ES2025'
+			| 'ES2025.Collection'
+			| 'ES2025.Float16'
+			| 'ES2025.Intl'
+			| 'ES2025.Iterator'
+			| 'ES2025.Promise'
+			| 'ES2025.RegExp'
 			| 'ESNext'
 			| 'ESNext.Array'
 			| 'ESNext.AsyncIterable'
@@ -156,6 +165,7 @@ export namespace TsConfigJson {
 			| 'ESNext.Decorators'
 			| 'ESNext.Disposable'
 			| 'ESNext.Error'
+			| 'ESNext.Float16'
 			| 'ESNext.Intl'
 			| 'ESNext.Iterator'
 			| 'ESNext.Object'
@@ -163,6 +173,7 @@ export namespace TsConfigJson {
 			| 'ESNext.Regexp'
 			| 'ESNext.String'
 			| 'ESNext.Symbol'
+			| 'ESNext.Temporal'
 			| 'ESNext.WeakRef'
 			| 'DOM'
 			| 'DOM.AsyncIterable'
@@ -244,6 +255,13 @@ export namespace TsConfigJson {
 			| 'es2024.regexp'
 			| 'es2024.sharedmemory'
 			| 'es2024.string'
+			| 'es2025'
+			| 'es2025.collection'
+			| 'es2025.float16'
+			| 'es2025.intl'
+			| 'es2025.iterator'
+			| 'es2025.promise'
+			| 'es2025.regexp'
 			| 'esnext'
 			| 'esnext.array'
 			| 'esnext.asynciterable'
@@ -252,6 +270,7 @@ export namespace TsConfigJson {
 			| 'esnext.decorators'
 			| 'esnext.disposable'
 			| 'esnext.error'
+			| 'esnext.float16'
 			| 'esnext.intl'
 			| 'esnext.iterator'
 			| 'esnext.object'
@@ -259,6 +278,7 @@ export namespace TsConfigJson {
 			| 'esnext.regexp'
 			| 'esnext.string'
 			| 'esnext.symbol'
+			| 'esnext.temporal'
 			| 'esnext.weakref'
 			| 'dom'
 			| 'dom.asynciterable'
@@ -326,7 +346,7 @@ export namespace TsConfigJson {
 			| 'legacy'
 			| 'force';
 
-		type IgnoreDeprecations = '5.0';
+		type IgnoreDeprecations = '5.0' | '6.0';
 	}
 
 	type CompilerOptions = {
@@ -479,7 +499,7 @@ export namespace TsConfigJson {
 		/**
 		Specify module code generation: 'None', 'CommonJS', 'AMD', 'System', 'UMD', 'ES6', 'ES2015' or 'ESNext'. Only 'AMD' and 'System' can be used in conjunction with `--outFile`. 'ES6' and 'ES2015' values may be used when targeting 'ES5' or lower.
 
-		@default ['ES3', 'ES5'].includes(target) ? 'CommonJS' : 'ES6'
+		Default: `'ESNext'` since TypeScript 6.0, `['ES3', 'ES5'].includes(target) ? 'CommonJS' : 'ES6'` before.
 		*/
 		module?: CompilerOptions.Module;
 
@@ -587,8 +607,17 @@ export namespace TsConfigJson {
 		*/
 		skipLibCheck?: boolean;
 
+		/**
+		Enforce stable type ordering.
+
+		@default false
+		*/
+		stableTypeOrdering?: boolean;
+
 		/**
 		Concatenate and emit output to single file.
+
+		@deprecated since TypeScript 6.0.
 		*/
 		outFile?: string;
 
@@ -696,7 +725,7 @@ export namespace TsConfigJson {
 		/**
 		Specify ECMAScript target version.
 
-		@default 'es3'
+		Default: Current-year ES version since TypeScript 6.0, `'es3'` before.
 		*/
 		target?: CompilerOptions.Target;
 
@@ -776,7 +805,7 @@ export namespace TsConfigJson {
 		/**
 		Report error if failed to find a source file for a side effect import.
 
-		@default false
+		Default: `true` since TypeScript 6.0, `false` before.
 		*/
 		noUncheckedSideEffectImports?: boolean;
 
@@ -822,6 +851,8 @@ export namespace TsConfigJson {
 
 		/**
 		Base directory to resolve non-relative module names.
+
+		@deprecated since TypeScript 6.0.
 		*/
 		baseUrl?: string;
 
@@ -944,7 +975,7 @@ export namespace TsConfigJson {
 		/**
 		Enable all strict type checking options.
 
-		@default false
+		Default: `true` since TypeScript 6.0, `false` before.
 		*/
 		strict?: boolean;
 
@@ -959,6 +990,7 @@ export namespace TsConfigJson {
 		Provide full support for iterables in `for-of`, spread, and destructuring when targeting `ES5` or `ES3`.
 
 		@default false
+		@deprecated since TypeScript 6.0.
 		*/
 		downlevelIteration?: boolean;
 
@@ -1150,7 +1182,7 @@ export namespace TsConfigJson {
 		/**
 		Enable lib replacement.
 
-		@default true
+		Default: `false` since TypeScript 6.0, `true` before.
 		*/
 		libReplacement?: boolean;
 	};
@@ -1234,7 +1266,7 @@ export namespace TsConfigJson {
 		exclude?: string[];
 
 		/**
-		Disable infering what types should be added based on filenames in a project.
+		Disable inferring what types should be added based on filenames in a project.
 		*/
 		disableFilenameBasedTypeAcquisition?: boolean;
 	};
@@ -1266,7 +1298,7 @@ export namespace TsConfigJson {
 }
 
 /**
-Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) (TypeScript 3.7).
+Type for [TypeScript's `tsconfig.json` file](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html).
 
 @category File
 */