From 9e886be6f6fa1bfb7e772cda51cbfdebd73a958a Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Thu, 4 Feb 2021 13:26:51 +0800
Subject: [PATCH 01/41] feat: add xxx-cased-props and xxx-cased-props-deep
 typings

---
 test-d/camel-cased-props-deep.ts     | 37 +++++++++++++++++++++++
 test-d/camel-cased-props.ts          | 23 ++++++++++++++
 test-d/delimiter-cased-props-deep.ts | 34 +++++++++++++++++++++
 test-d/delimiter-cased-props.ts      | 16 ++++++++++
 test-d/kebab-cased-props-deep.ts     | 34 +++++++++++++++++++++
 test-d/kebab-cased-props.ts          | 16 ++++++++++
 test-d/pascal-cased-props-deep.ts    | 34 +++++++++++++++++++++
 test-d/pascal-cased-props.ts         | 16 ++++++++++
 test-d/snake-cased-props-deep.ts     | 34 +++++++++++++++++++++
 test-d/snake-cased-props.ts          | 16 ++++++++++
 ts41/camel-cased-props-deep.d.ts     | 45 ++++++++++++++++++++++++++++
 ts41/camel-cased-props.d.ts          | 28 +++++++++++++++++
 ts41/delimiter-cased-props-deep.d.ts | 43 ++++++++++++++++++++++++++
 ts41/delimiter-cased-props.d.ts      | 24 +++++++++++++++
 ts41/kebab-cased-props-deep.d.ts     | 41 +++++++++++++++++++++++++
 ts41/kebab-cased-props.d.ts          | 22 ++++++++++++++
 ts41/pascal-cased-props-deep.d.ts    | 44 +++++++++++++++++++++++++++
 ts41/pascal-cased-props.d.ts         | 25 ++++++++++++++++
 ts41/snake-cased-props-deep.d.ts     | 40 +++++++++++++++++++++++++
 ts41/snake-cased-props.d.ts          | 23 ++++++++++++++
 20 files changed, 595 insertions(+)
 create mode 100644 test-d/camel-cased-props-deep.ts
 create mode 100644 test-d/camel-cased-props.ts
 create mode 100644 test-d/delimiter-cased-props-deep.ts
 create mode 100644 test-d/delimiter-cased-props.ts
 create mode 100644 test-d/kebab-cased-props-deep.ts
 create mode 100644 test-d/kebab-cased-props.ts
 create mode 100644 test-d/pascal-cased-props-deep.ts
 create mode 100644 test-d/pascal-cased-props.ts
 create mode 100644 test-d/snake-cased-props-deep.ts
 create mode 100644 test-d/snake-cased-props.ts
 create mode 100644 ts41/camel-cased-props-deep.d.ts
 create mode 100644 ts41/camel-cased-props.d.ts
 create mode 100644 ts41/delimiter-cased-props-deep.d.ts
 create mode 100644 ts41/delimiter-cased-props.d.ts
 create mode 100644 ts41/kebab-cased-props-deep.d.ts
 create mode 100644 ts41/kebab-cased-props.d.ts
 create mode 100644 ts41/pascal-cased-props-deep.d.ts
 create mode 100644 ts41/pascal-cased-props.d.ts
 create mode 100644 ts41/snake-cased-props-deep.d.ts
 create mode 100644 ts41/snake-cased-props.d.ts

diff --git a/test-d/camel-cased-props-deep.ts b/test-d/camel-cased-props-deep.ts
new file mode 100644
index 000000000..1a5377263
--- /dev/null
+++ b/test-d/camel-cased-props-deep.ts
@@ -0,0 +1,37 @@
+import {CamelCasedPropsDeep} from '../ts41/camel-cased-props-deep';
+import {expectType} from 'tsd';
+
+declare const foo: CamelCasedPropsDeep<{
+	A: { B: number; C: Array<{ D: string }> };
+}>;
+
+expectType<{ a: { b: number; c: Array<{ d: string }> } }>(foo);
+
+// Verify Example
+interface User {
+	UserId: number;
+	UserName: string;
+}
+
+interface UserWithFriends {
+	UserInfo: User;
+	UserFriends: User[];
+}
+
+const result: CamelCasedPropsDeep<UserWithFriends> = {
+	userInfo: {
+		userId: 1,
+		userName: 'Tom'
+	},
+	userFriends: [
+		{
+			userId: 2,
+			userName: 'Jerry'
+		},
+		{
+			userId: 3,
+			userName: 'Spike'
+		}
+	]
+};
+expectType<CamelCasedPropsDeep<UserWithFriends>>(result);
diff --git a/test-d/camel-cased-props.ts b/test-d/camel-cased-props.ts
new file mode 100644
index 000000000..18c00c21e
--- /dev/null
+++ b/test-d/camel-cased-props.ts
@@ -0,0 +1,23 @@
+import {CamelCasedProps} from '../ts41/camel-cased-props';
+import {expectType} from 'tsd';
+
+declare const foo: CamelCasedProps<{
+	A: number;
+	B: {
+		C: string;
+	};
+}>;
+
+expectType<{ a: number; b: { C: string } }>(foo);
+
+// Verify Example
+interface User {
+	UserId: number;
+	UserName: string;
+}
+
+const result: CamelCasedProps<User> = {
+	userId: 1,
+	userName: 'Tom'
+};
+expectType<CamelCasedProps<User>>(result);
diff --git a/test-d/delimiter-cased-props-deep.ts b/test-d/delimiter-cased-props-deep.ts
new file mode 100644
index 000000000..d1d08c3cf
--- /dev/null
+++ b/test-d/delimiter-cased-props-deep.ts
@@ -0,0 +1,34 @@
+import {expectType} from 'tsd';
+import {DelimiterCasedPropsDeep} from '../ts41/delimiter-cased-props-deep';
+
+declare const foo: DelimiterCasedPropsDeep<{helloWorld: {fooBar: string}}, '/'>;
+expectType<{'hello/world': {'foo/bar': string}}>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: DelimiterCasedPropsDeep<UserWithFriends, '-'> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom'
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry'
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike'
+		}
+	]
+};
+expectType<DelimiterCasedPropsDeep<UserWithFriends, '-'>>(result);
diff --git a/test-d/delimiter-cased-props.ts b/test-d/delimiter-cased-props.ts
new file mode 100644
index 000000000..122df952c
--- /dev/null
+++ b/test-d/delimiter-cased-props.ts
@@ -0,0 +1,16 @@
+import {expectType} from 'tsd';
+import {DelimiterCasedProps} from '../ts41/delimiter-cased-props';
+
+declare const foo: DelimiterCasedProps<{ helloWorld: { fooBar: string } }, '/'>;
+expectType<{ 'hello/world': { fooBar: string } }>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: DelimiterCasedProps<User, '-'> = {
+	'user-id': 1,
+	'user-name': 'Tom'
+};
+expectType<DelimiterCasedProps<User, '-'>>(result);
diff --git a/test-d/kebab-cased-props-deep.ts b/test-d/kebab-cased-props-deep.ts
new file mode 100644
index 000000000..eb4349846
--- /dev/null
+++ b/test-d/kebab-cased-props-deep.ts
@@ -0,0 +1,34 @@
+import {KebabCasedPropsDeep} from '../ts41/kebab-cased-props-deep';
+import {expectType} from 'tsd';
+
+declare const foo: KebabCasedPropsDeep<{helloWorld: {fooBar: string}}>;
+expectType<{'hello-world': {'foo-bar': string}}>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: KebabCasedPropsDeep<UserWithFriends> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': 'Tom'
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry'
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike'
+		}
+	]
+};
+expectType<KebabCasedPropsDeep<UserWithFriends>>(result);
diff --git a/test-d/kebab-cased-props.ts b/test-d/kebab-cased-props.ts
new file mode 100644
index 000000000..8eb9fed69
--- /dev/null
+++ b/test-d/kebab-cased-props.ts
@@ -0,0 +1,16 @@
+import {KebabCasedProps} from '../ts41/kebab-cased-props';
+import {expectType} from 'tsd';
+
+declare const foo: KebabCasedProps<{ helloWorld: { fooBar: string } }>;
+expectType<{ 'hello-world': { fooBar: string } }>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: KebabCasedProps<User> = {
+	'user-id': 1,
+	'user-name': 'Tom'
+};
+expectType<KebabCasedProps<User>>(result);
diff --git a/test-d/pascal-cased-props-deep.ts b/test-d/pascal-cased-props-deep.ts
new file mode 100644
index 000000000..230c9be94
--- /dev/null
+++ b/test-d/pascal-cased-props-deep.ts
@@ -0,0 +1,34 @@
+import {PascalCasedPropsDeep} from '../ts41/pascal-cased-props-deep';
+import {expectType} from 'tsd';
+
+declare const foo: PascalCasedPropsDeep<{ helloWorld: { fooBar: string } }>;
+expectType<{ HelloWorld: { FooBar: string } }>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: PascalCasedPropsDeep<UserWithFriends> = {
+	UserInfo: {
+		UserId: 1,
+		UserName: 'Tom'
+	},
+	UserFriends: [
+		{
+			UserId: 2,
+			UserName: 'Jerry'
+		},
+		{
+			UserId: 3,
+			UserName: 'Spike'
+		}
+	]
+};
+expectType<PascalCasedPropsDeep<UserWithFriends>>(result);
diff --git a/test-d/pascal-cased-props.ts b/test-d/pascal-cased-props.ts
new file mode 100644
index 000000000..cc845eed7
--- /dev/null
+++ b/test-d/pascal-cased-props.ts
@@ -0,0 +1,16 @@
+import {PascalCasedProps} from '../ts41/pascal-cased-props';
+import {expectType} from 'tsd';
+
+declare const foo: PascalCasedProps<{ helloWorld: { fooBar: string } }>;
+expectType<{ HelloWorld: { fooBar: string } }>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: PascalCasedProps<User> = {
+	UserId: 1,
+	UserName: 'Tom'
+};
+expectType<PascalCasedProps<User>>(result);
diff --git a/test-d/snake-cased-props-deep.ts b/test-d/snake-cased-props-deep.ts
new file mode 100644
index 000000000..d566f2447
--- /dev/null
+++ b/test-d/snake-cased-props-deep.ts
@@ -0,0 +1,34 @@
+import {SnakeCasedPropsDeep} from '../ts41/snake-cased-props-deep';
+import {expectType} from 'tsd';
+
+declare const foo: SnakeCasedPropsDeep<{ helloWorld: { fooBar: string } }>;
+expectType<{ hello_world: { foo_bar: string } }>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: SnakeCasedPropsDeep<UserWithFriends> = {
+	user_info: {
+		user_id: 1,
+		user_name: 'Tom'
+	},
+	user_friends: [
+		{
+			user_id: 2,
+			user_name: 'Jerry'
+		},
+		{
+			user_id: 3,
+			user_name: 'Spike'
+		}
+	]
+};
+expectType<SnakeCasedPropsDeep<UserWithFriends>>(result);
diff --git a/test-d/snake-cased-props.ts b/test-d/snake-cased-props.ts
new file mode 100644
index 000000000..f0460631c
--- /dev/null
+++ b/test-d/snake-cased-props.ts
@@ -0,0 +1,16 @@
+import {SnakeCasedProps} from '../ts41/snake-cased-props';
+import {expectType} from 'tsd';
+
+declare const foo: SnakeCasedProps<{ helloWorld: { fooBar: string } }>;
+expectType<{ hello_world: { fooBar: string } }>(foo);
+
+// Verify Example
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: SnakeCasedProps<User> = {
+	user_id: 1,
+	user_name: 'Tom'
+};
+expectType<SnakeCasedProps<User>>(result);
diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
new file mode 100644
index 000000000..6b18618c1
--- /dev/null
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -0,0 +1,45 @@
+import {CamelCase} from './camel-case';
+
+/**
+Convert object props to camelCase recursively.
+
+This can be useful when, for example, converting some API types from other style.
+
+@see CamelCasedProps
+@see CamelCase
+@example
+```
+interface User {
+    UserId: number;
+    UserName: string;
+}
+
+interface UserWithFriends {
+    UserInfo: User;
+    UserFriends: User[];
+}
+
+const result: CamelCasedPropsDeep<UserWithFriends> = {
+    userInfo: {
+        userId: 1,
+        userName: "Tom",
+    },
+    userFriends: [
+        {
+            userId: 2,
+            userName: "Jerry",
+        },
+        {
+            userId: 3,
+            userName: "Spike",
+        },
+    ],
+};
+
+```
+*/
+export type CamelCasedPropsDeep<T> = T extends Array<infer U>
+	? Array<CamelCasedPropsDeep<U>>
+	: {
+			[K in keyof T as CamelCase<K>]: CamelCasedPropsDeep<T[K]>;
+	};
diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-props.d.ts
new file mode 100644
index 000000000..2d32afc3c
--- /dev/null
+++ b/ts41/camel-cased-props.d.ts
@@ -0,0 +1,28 @@
+import {CamelCase} from './camel-case';
+
+/**
+Convert object props to camelCase but not recursively.
+
+This can be useful when, for example, converting some api type from other style.
+
+@see CamelCasedPropsDeep
+@see CamelCase
+@example
+```
+interface User {
+	UserId: number;
+	UserName: string;
+}
+
+const result: CamelCasedProps<User> = {
+	userId: 1,
+	userName: "Tom",
+};
+
+```
+*/
+export type CamelCasedProps<T> = T extends Array<infer U>
+	? U[]
+	: {
+			[K in keyof T as CamelCase<K>]: T[K];
+	};
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
new file mode 100644
index 000000000..0adb3761f
--- /dev/null
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -0,0 +1,43 @@
+import {DelimiterCase} from './delimiter-case';
+
+/**
+Convert object props to delimiter-case recursively.
+
+This can be useful when, for example, converting some API types from other style.
+
+@see DelimiterCase
+@see DelimiterCasedProps
+@example
+```
+interface User {
+    userId: number;
+    userName: string;
+}
+
+interface UserWithFriends {
+    userInfo: User;
+    userFriends: User[];
+}
+
+const result: DelimiterCasedPropsDeep<UserWithFriends, '-'> = {
+    'user-info': {
+        'user-id': 1,
+        'user-name': "Tom",
+    },
+    'user-friends': [
+        {
+            'user-id': 2,
+            'user-name': "Jerry",
+        },
+        {
+            'user-id': 3,
+            'user-name': "Spike",
+        },
+    ],
+};
+
+```
+*/
+export type DelimiterCasedPropsDeep<T, D extends string> = T extends Array<infer U> ? Array<DelimiterCasedPropsDeep<U, D>> : {
+            [K in keyof T as DelimiterCase<K, D>]: DelimiterCasedPropsDeep<T[K], D>;
+      };
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-props.d.ts
new file mode 100644
index 000000000..1d3ae81f8
--- /dev/null
+++ b/ts41/delimiter-cased-props.d.ts
@@ -0,0 +1,24 @@
+import {DelimiterCase} from './delimiter-case';
+
+/**
+Convert object props to delimiter-case but not recursively.
+
+This can be useful when, for example, converting some api type from other style.
+
+@see DelimiterCase
+@see DelimiterCasedPropsDeep
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: DelimiterCasedProps<User, "-"> = {
+	"user-id": 1,
+	"user-name": "Tom",
+};
+```
+*/
+export type DelimiterCasedProps<T, D extends string> = T extends Array<infer U>
+	? U[]
+	: { [K in keyof T as DelimiterCase<K, D>]: T[K] };
diff --git a/ts41/kebab-cased-props-deep.d.ts b/ts41/kebab-cased-props-deep.d.ts
new file mode 100644
index 000000000..146bd142a
--- /dev/null
+++ b/ts41/kebab-cased-props-deep.d.ts
@@ -0,0 +1,41 @@
+import {DelimiterCasedPropsDeep} from './delimiter-cased-props-deep';
+
+/**
+Convert object props to kebab-case recursively.
+
+This can be useful when, for example, converting some API types from other style.
+
+@see KebabCase
+@see KebabCasedProps
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: KebabCasedPropsDeep<UserWithFriends> = {
+	'user-info': {
+		'user-id': 1,
+		'user-name': "Tom",
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': "Jerry",
+		},
+		{
+			'user-id': 3,
+			'user-name': "Spike",
+		},
+	],
+};
+
+```
+*/
+export type KebabCasedPropsDeep<T> = DelimiterCasedPropsDeep<T, '-'>;
diff --git a/ts41/kebab-cased-props.d.ts b/ts41/kebab-cased-props.d.ts
new file mode 100644
index 000000000..f27222243
--- /dev/null
+++ b/ts41/kebab-cased-props.d.ts
@@ -0,0 +1,22 @@
+import {DelimiterCasedProps} from './delimiter-cased-props';
+
+/**
+Convert object props to kebab-case but not recursively.
+
+This can be useful when, for example, converting some api type from other style.
+
+@see KebabCase
+@see KebabCasedPropsDeep
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: KebabCasedProps<User> = {
+	"user-id": 1,
+	"user-name": "Tom",
+};
+```
+*/
+export type KebabCasedProps<T> = DelimiterCasedProps<T, '-'>;
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-props-deep.d.ts
new file mode 100644
index 000000000..85cd9bca3
--- /dev/null
+++ b/ts41/pascal-cased-props-deep.d.ts
@@ -0,0 +1,44 @@
+import {PascalCase} from './pascal-case';
+
+/**
+Convert object props to PascalCase recursively.
+
+This can be useful when, for example, converting some API types from other style.
+
+@see PascalCase
+@see PascalCasedProps
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: PascalCasedPropsDeep<UserWithFriends> = {
+	UserInfo: {
+		UserId: 1,
+		UserName: "Tom",
+	},
+	UserFriends: [
+		{
+			UserId: 2,
+			UserName: "Jerry",
+		},
+		{
+			UserId: 3,
+			UserName: "Spike",
+		},
+	],
+};
+
+*/
+export type PascalCasedPropsDeep<T> = T extends Array<infer U>
+	? Array<PascalCasedPropsDeep<U>>
+	: {
+			[K in keyof T as PascalCase<K>]: PascalCasedPropsDeep<T[K]>;
+	};
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-props.d.ts
new file mode 100644
index 000000000..7cb1cf7f0
--- /dev/null
+++ b/ts41/pascal-cased-props.d.ts
@@ -0,0 +1,25 @@
+import {PascalCase} from './pascal-case';
+
+/**
+Convert object props to PascalCase but not recursively.
+
+This can be useful when, for example, converting some api type from other style.
+
+@see PascalCase
+@see PascalCasedPropsDeep
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: PascalCasedProps<User> = {
+	UserId: 1,
+	UserName: "Tom",
+};
+
+```
+*/
+export type PascalCasedProps<T> = T extends Array<infer U>
+	? U[]
+	: { [K in keyof T as PascalCase<K>]: T[K] };
diff --git a/ts41/snake-cased-props-deep.d.ts b/ts41/snake-cased-props-deep.d.ts
new file mode 100644
index 000000000..e8a7a796b
--- /dev/null
+++ b/ts41/snake-cased-props-deep.d.ts
@@ -0,0 +1,40 @@
+import {DelimiterCasedPropsDeep} from './delimiter-cased-props-deep';
+
+/**
+Convert object props to snake_case recursively.
+
+This can be useful when, for example, converting some API types from other style.
+
+@see SnakeCase
+@see SnakeCasedProps
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+
+interface UserWithFriends {
+	userInfo: User;
+	userFriends: User[];
+}
+
+const result: SnakeCasedPropsDeep<UserWithFriends> = {
+	user_info: {
+		user_id: 1,
+		user_name: "Tom",
+	},
+	user_friends: [
+		{
+			user_id: 2,
+			user_name: "Jerry",
+		},
+		{
+			user_id: 3,
+			user_name: "Spike",
+		},
+	],
+};
+
+*/
+export type SnakeCasedPropsDeep<T> = DelimiterCasedPropsDeep<T, '_'>;
diff --git a/ts41/snake-cased-props.d.ts b/ts41/snake-cased-props.d.ts
new file mode 100644
index 000000000..f92e0c8ef
--- /dev/null
+++ b/ts41/snake-cased-props.d.ts
@@ -0,0 +1,23 @@
+import {DelimiterCasedProps} from './delimiter-cased-props';
+
+/**
+Convert object props to snake_case but not recursively.
+
+This can be useful when, for example, converting some api type from other style.
+
+@see SnakeCase
+@see SnakeCasedPropsDeep
+@example
+```
+interface User {
+	userId: number;
+	userName: string;
+}
+const result: SnakeCasedProps<User> = {
+	user_id: 1,
+	user_name: "Tom",
+};
+
+```
+*/
+export type SnakeCasedProps<T> = DelimiterCasedProps<T, '_'>;

From d3bc9fbd54de9f206ee4d75691770e375da76e25 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Thu, 4 Feb 2021 13:40:11 +0800
Subject: [PATCH 02/41] doc: update README.md

---
 readme.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/readme.md b/readme.md
index 4fae2d385..a6ac20c82 100644
--- a/readme.md
+++ b/readme.md
@@ -110,12 +110,28 @@ Click the type names for complete docs.
 *Note:* These require [TypeScript 4.1 or newer](https://devblogs.microsoft.com/typescript/announcing-typescript-4-1/#template-literal-types).
 
 - [`CamelCase`](ts41/camel-case.d.ts) – Convert a string literal to camel-case (`fooBar`).
+- [`CamelCasedProps`](ts41/camel-cased-props.d.ts) – Convert object props to camel-case  (`fooBar`).
+- [`CamelCasedPropsDeep`](ts41/camel-cased-props-deep.d.ts) – Convert object props to camel-case recursively  (`fooBar`).
+
 - [`KebabCase`](ts41/kebab-case.d.ts) – Convert a string literal to kebab-case (`foo-bar`).
+- [`KebabCasedProps`](ts41/kebab-cased-props.d.ts) – Convert a object props to kebab-case recursively (`foo-bar`).
+- [`KebabCasedPropsDeep`](ts41/kebab-cased-props-deep.d.ts) – Convert object props to kebab-case (`foo-bar`).
+
 - [`PascalCase`](ts41/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
+- [`PascalCasedProps`](ts41/pascal-cased-props.d.ts) – Converts object props to pascal-case (`FooBar`)
+- [`PascalCasedPropsDeep`](ts41/pascal-cased-props-deep.d.ts) – Converts object props to pascal-case (`FooBar`)
+
 - [`SnakeCase`](ts41/snake-case.d.ts) – Convert a string literal to snake-case (`foo_bar`).
+- [`SnakeCasedProps`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case (`foo_bar`).
+- [`SnakeCasedPropsDeep`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case recursively (`foo_bar`).
+
 - [`DelimiterCase`](ts41/delimiter-case.d.ts) – Convert a string literal to a custom string delimiter casing.
+- [`DelimiterCasedProps`](ts41/delimiter-cased-props.d.ts) – Convert object props to a custom string delimiter casing.
+- [`DelimiterCasedPropsDeep`](ts41/delimiter-cased-props-deep.d.ts) – Convert object props to a custom string delimiter casing recursively.
+
 - [`Get`](ts41/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 
+
 ### Miscellaneous
 
 - [`PackageJson`](source/package-json.d.ts) - Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file).

From bd43b8fb7bf01532c227c92f1f9ba503b755353d Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:05:51 +0800
Subject: [PATCH 03/41] chore: rename XXXCasedProps to XXXCasedProperties

---
 readme.md                            | 20 ++++++++++----------
 test-d/camel-case.ts                 |  4 ++--
 test-d/camel-cased-props-deep.ts     |  8 ++++----
 test-d/camel-cased-props.ts          |  8 ++++----
 test-d/delimiter-case.ts             |  4 ++--
 test-d/delimiter-cased-props-deep.ts |  8 ++++----
 test-d/delimiter-cased-props.ts      |  8 ++++----
 test-d/kebab-cased-props-deep.ts     |  8 ++++----
 test-d/kebab-cased-props.ts          |  8 ++++----
 test-d/pascal-cased-props-deep.ts    |  8 ++++----
 test-d/pascal-cased-props.ts         |  8 ++++----
 test-d/snake-cased-props-deep.ts     |  8 ++++----
 test-d/snake-cased-props.ts          |  8 ++++----
 ts41/camel-case.d.ts                 |  4 ++--
 ts41/camel-cased-props-deep.d.ts     | 10 +++++-----
 ts41/camel-cased-props.d.ts          |  6 +++---
 ts41/delimiter-case.d.ts             |  4 ++--
 ts41/delimiter-cased-props-deep.d.ts |  8 ++++----
 ts41/delimiter-cased-props.d.ts      |  6 +++---
 ts41/kebab-case.d.ts                 |  4 ++--
 ts41/kebab-cased-props-deep.d.ts     |  8 ++++----
 ts41/kebab-cased-props.d.ts          |  8 ++++----
 ts41/pascal-case.d.ts                |  2 +-
 ts41/pascal-cased-props-deep.d.ts    | 10 +++++-----
 ts41/pascal-cased-props.d.ts         |  6 +++---
 ts41/snake-case.d.ts                 |  4 ++--
 ts41/snake-cased-props-deep.d.ts     |  8 ++++----
 ts41/snake-cased-props.d.ts          |  8 ++++----
 28 files changed, 102 insertions(+), 102 deletions(-)

diff --git a/readme.md b/readme.md
index a6ac20c82..a8716c5bd 100644
--- a/readme.md
+++ b/readme.md
@@ -110,24 +110,24 @@ Click the type names for complete docs.
 *Note:* These require [TypeScript 4.1 or newer](https://devblogs.microsoft.com/typescript/announcing-typescript-4-1/#template-literal-types).
 
 - [`CamelCase`](ts41/camel-case.d.ts) – Convert a string literal to camel-case (`fooBar`).
-- [`CamelCasedProps`](ts41/camel-cased-props.d.ts) – Convert object props to camel-case  (`fooBar`).
-- [`CamelCasedPropsDeep`](ts41/camel-cased-props-deep.d.ts) – Convert object props to camel-case recursively  (`fooBar`).
+- [`CamelCasedProperties`](ts41/camel-cased-props.d.ts) – Convert object props to camel-case  (`fooBar`).
+- [`CamelCasedPropertiesDeep`](ts41/camel-cased-props-deep.d.ts) – Convert object props to camel-case recursively  (`fooBar`).
 
 - [`KebabCase`](ts41/kebab-case.d.ts) – Convert a string literal to kebab-case (`foo-bar`).
-- [`KebabCasedProps`](ts41/kebab-cased-props.d.ts) – Convert a object props to kebab-case recursively (`foo-bar`).
-- [`KebabCasedPropsDeep`](ts41/kebab-cased-props-deep.d.ts) – Convert object props to kebab-case (`foo-bar`).
+- [`KebabCasedProperties`](ts41/kebab-cased-props.d.ts) – Convert a object props to kebab-case recursively (`foo-bar`).
+- [`KebabCasedPropertiesDeep`](ts41/kebab-cased-props-deep.d.ts) – Convert object props to kebab-case (`foo-bar`).
 
 - [`PascalCase`](ts41/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
-- [`PascalCasedProps`](ts41/pascal-cased-props.d.ts) – Converts object props to pascal-case (`FooBar`)
-- [`PascalCasedPropsDeep`](ts41/pascal-cased-props-deep.d.ts) – Converts object props to pascal-case (`FooBar`)
+- [`PascalCasedProperties`](ts41/pascal-cased-props.d.ts) – Converts object props to pascal-case (`FooBar`)
+- [`PascalCasedPropertiesDeep`](ts41/pascal-cased-props-deep.d.ts) – Converts object props to pascal-case (`FooBar`)
 
 - [`SnakeCase`](ts41/snake-case.d.ts) – Convert a string literal to snake-case (`foo_bar`).
-- [`SnakeCasedProps`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case (`foo_bar`).
-- [`SnakeCasedPropsDeep`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case recursively (`foo_bar`).
+- [`SnakeCasedProperties`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case (`foo_bar`).
+- [`SnakeCasedPropertiesDeep`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case recursively (`foo_bar`).
 
 - [`DelimiterCase`](ts41/delimiter-case.d.ts) – Convert a string literal to a custom string delimiter casing.
-- [`DelimiterCasedProps`](ts41/delimiter-cased-props.d.ts) – Convert object props to a custom string delimiter casing.
-- [`DelimiterCasedPropsDeep`](ts41/delimiter-cased-props-deep.d.ts) – Convert object props to a custom string delimiter casing recursively.
+- [`DelimiterCasedProperties`](ts41/delimiter-cased-props.d.ts) – Convert object props to a custom string delimiter casing.
+- [`DelimiterCasedPropertiesDeep`](ts41/delimiter-cased-props-deep.d.ts) – Convert object props to a custom string delimiter casing recursively.
 
 - [`Get`](ts41/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 
diff --git a/test-d/camel-case.ts b/test-d/camel-case.ts
index 9431d7c42..d3df04d35 100644
--- a/test-d/camel-case.ts
+++ b/test-d/camel-case.ts
@@ -38,7 +38,7 @@ const camelFromRepeatedSeparators: CamelCase<'foo____bar'> = 'fooBar';
 expectType<'fooBar'>(camelFromRepeatedSeparators);
 
 // Verifying example
-type CamelCasedProps<T> = {
+type CamelCasedProperties<T> = {
 	[K in keyof T as CamelCase<K>]: T[K]
 };
 
@@ -48,7 +48,7 @@ interface RawOptions {
 	foo: number;
 }
 
-expectAssignable<CamelCasedProps<RawOptions>>({
+expectAssignable<CamelCasedProperties<RawOptions>>({
 	dryRun: true,
 	fullFamilyName: 'bar.js',
 	foo: 123
diff --git a/test-d/camel-cased-props-deep.ts b/test-d/camel-cased-props-deep.ts
index 1a5377263..7d433ca84 100644
--- a/test-d/camel-cased-props-deep.ts
+++ b/test-d/camel-cased-props-deep.ts
@@ -1,7 +1,7 @@
-import {CamelCasedPropsDeep} from '../ts41/camel-cased-props-deep';
+import {CamelCasedPropertiesDeep} from '../ts41/camel-cased-props-deep';
 import {expectType} from 'tsd';
 
-declare const foo: CamelCasedPropsDeep<{
+declare const foo: CamelCasedPropertiesDeep<{
 	A: { B: number; C: Array<{ D: string }> };
 }>;
 
@@ -18,7 +18,7 @@ interface UserWithFriends {
 	UserFriends: User[];
 }
 
-const result: CamelCasedPropsDeep<UserWithFriends> = {
+const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 	userInfo: {
 		userId: 1,
 		userName: 'Tom'
@@ -34,4 +34,4 @@ const result: CamelCasedPropsDeep<UserWithFriends> = {
 		}
 	]
 };
-expectType<CamelCasedPropsDeep<UserWithFriends>>(result);
+expectType<CamelCasedPropertiesDeep<UserWithFriends>>(result);
diff --git a/test-d/camel-cased-props.ts b/test-d/camel-cased-props.ts
index 18c00c21e..0b4b77b0a 100644
--- a/test-d/camel-cased-props.ts
+++ b/test-d/camel-cased-props.ts
@@ -1,7 +1,7 @@
-import {CamelCasedProps} from '../ts41/camel-cased-props';
+import {CamelCasedProperties} from '../ts41/camel-cased-props';
 import {expectType} from 'tsd';
 
-declare const foo: CamelCasedProps<{
+declare const foo: CamelCasedProperties<{
 	A: number;
 	B: {
 		C: string;
@@ -16,8 +16,8 @@ interface User {
 	UserName: string;
 }
 
-const result: CamelCasedProps<User> = {
+const result: CamelCasedProperties<User> = {
 	userId: 1,
 	userName: 'Tom'
 };
-expectType<CamelCasedProps<User>>(result);
+expectType<CamelCasedProperties<User>>(result);
diff --git a/test-d/delimiter-case.ts b/test-d/delimiter-case.ts
index a92d62ad7..ed284c2f2 100644
--- a/test-d/delimiter-case.ts
+++ b/test-d/delimiter-case.ts
@@ -44,7 +44,7 @@ const delimiterFromRepeatedSeparators: DelimiterCase<'foo____bar', '#'> = 'foo##
 expectType<'foo####bar'>(delimiterFromRepeatedSeparators);
 
 // Verifying example
-type OddCasedProps<T> = {
+type OddCasedProperties<T> = {
 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
 };
 
@@ -54,7 +54,7 @@ interface CliOptions {
 	foo: number;
 }
 
-expectAssignable<OddCasedProps<CliOptions>>({
+expectAssignable<OddCasedProperties<CliOptions>>({
 	'dry#run': true,
 	'include#file': 'bar.js',
 	foo: 123
diff --git a/test-d/delimiter-cased-props-deep.ts b/test-d/delimiter-cased-props-deep.ts
index d1d08c3cf..33cf99a21 100644
--- a/test-d/delimiter-cased-props-deep.ts
+++ b/test-d/delimiter-cased-props-deep.ts
@@ -1,7 +1,7 @@
 import {expectType} from 'tsd';
-import {DelimiterCasedPropsDeep} from '../ts41/delimiter-cased-props-deep';
+import {DelimiterCasedPropertiesDeep} from '../ts41/delimiter-cased-props-deep';
 
-declare const foo: DelimiterCasedPropsDeep<{helloWorld: {fooBar: string}}, '/'>;
+declare const foo: DelimiterCasedPropertiesDeep<{helloWorld: {fooBar: string}}, '/'>;
 expectType<{'hello/world': {'foo/bar': string}}>(foo);
 
 // Verify Example
@@ -15,7 +15,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: DelimiterCasedPropsDeep<UserWithFriends, '-'> = {
+const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 	'user-info': {
 		'user-id': 1,
 		'user-name': 'Tom'
@@ -31,4 +31,4 @@ const result: DelimiterCasedPropsDeep<UserWithFriends, '-'> = {
 		}
 	]
 };
-expectType<DelimiterCasedPropsDeep<UserWithFriends, '-'>>(result);
+expectType<DelimiterCasedPropertiesDeep<UserWithFriends, '-'>>(result);
diff --git a/test-d/delimiter-cased-props.ts b/test-d/delimiter-cased-props.ts
index 122df952c..529739c8d 100644
--- a/test-d/delimiter-cased-props.ts
+++ b/test-d/delimiter-cased-props.ts
@@ -1,7 +1,7 @@
 import {expectType} from 'tsd';
-import {DelimiterCasedProps} from '../ts41/delimiter-cased-props';
+import {DelimiterCasedProperties} from '../ts41/delimiter-cased-props';
 
-declare const foo: DelimiterCasedProps<{ helloWorld: { fooBar: string } }, '/'>;
+declare const foo: DelimiterCasedProperties<{ helloWorld: { fooBar: string } }, '/'>;
 expectType<{ 'hello/world': { fooBar: string } }>(foo);
 
 // Verify Example
@@ -9,8 +9,8 @@ interface User {
 	userId: number;
 	userName: string;
 }
-const result: DelimiterCasedProps<User, '-'> = {
+const result: DelimiterCasedProperties<User, '-'> = {
 	'user-id': 1,
 	'user-name': 'Tom'
 };
-expectType<DelimiterCasedProps<User, '-'>>(result);
+expectType<DelimiterCasedProperties<User, '-'>>(result);
diff --git a/test-d/kebab-cased-props-deep.ts b/test-d/kebab-cased-props-deep.ts
index eb4349846..243b71391 100644
--- a/test-d/kebab-cased-props-deep.ts
+++ b/test-d/kebab-cased-props-deep.ts
@@ -1,7 +1,7 @@
-import {KebabCasedPropsDeep} from '../ts41/kebab-cased-props-deep';
+import {KebabCasedPropertiesDeep} from '../ts41/kebab-cased-props-deep';
 import {expectType} from 'tsd';
 
-declare const foo: KebabCasedPropsDeep<{helloWorld: {fooBar: string}}>;
+declare const foo: KebabCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
 expectType<{'hello-world': {'foo-bar': string}}>(foo);
 
 // Verify Example
@@ -15,7 +15,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: KebabCasedPropsDeep<UserWithFriends> = {
+const result: KebabCasedPropertiesDeep<UserWithFriends> = {
 	'user-info': {
 		'user-id': 1,
 		'user-name': 'Tom'
@@ -31,4 +31,4 @@ const result: KebabCasedPropsDeep<UserWithFriends> = {
 		}
 	]
 };
-expectType<KebabCasedPropsDeep<UserWithFriends>>(result);
+expectType<KebabCasedPropertiesDeep<UserWithFriends>>(result);
diff --git a/test-d/kebab-cased-props.ts b/test-d/kebab-cased-props.ts
index 8eb9fed69..a8972b2ef 100644
--- a/test-d/kebab-cased-props.ts
+++ b/test-d/kebab-cased-props.ts
@@ -1,7 +1,7 @@
-import {KebabCasedProps} from '../ts41/kebab-cased-props';
+import {KebabCasedProperties} from '../ts41/kebab-cased-props';
 import {expectType} from 'tsd';
 
-declare const foo: KebabCasedProps<{ helloWorld: { fooBar: string } }>;
+declare const foo: KebabCasedProperties<{ helloWorld: { fooBar: string } }>;
 expectType<{ 'hello-world': { fooBar: string } }>(foo);
 
 // Verify Example
@@ -9,8 +9,8 @@ interface User {
 	userId: number;
 	userName: string;
 }
-const result: KebabCasedProps<User> = {
+const result: KebabCasedProperties<User> = {
 	'user-id': 1,
 	'user-name': 'Tom'
 };
-expectType<KebabCasedProps<User>>(result);
+expectType<KebabCasedProperties<User>>(result);
diff --git a/test-d/pascal-cased-props-deep.ts b/test-d/pascal-cased-props-deep.ts
index 230c9be94..e44b9a952 100644
--- a/test-d/pascal-cased-props-deep.ts
+++ b/test-d/pascal-cased-props-deep.ts
@@ -1,7 +1,7 @@
-import {PascalCasedPropsDeep} from '../ts41/pascal-cased-props-deep';
+import {PascalCasedPropertiesDeep} from '../ts41/pascal-cased-props-deep';
 import {expectType} from 'tsd';
 
-declare const foo: PascalCasedPropsDeep<{ helloWorld: { fooBar: string } }>;
+declare const foo: PascalCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
 expectType<{ HelloWorld: { FooBar: string } }>(foo);
 
 // Verify Example
@@ -15,7 +15,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: PascalCasedPropsDeep<UserWithFriends> = {
+const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 	UserInfo: {
 		UserId: 1,
 		UserName: 'Tom'
@@ -31,4 +31,4 @@ const result: PascalCasedPropsDeep<UserWithFriends> = {
 		}
 	]
 };
-expectType<PascalCasedPropsDeep<UserWithFriends>>(result);
+expectType<PascalCasedPropertiesDeep<UserWithFriends>>(result);
diff --git a/test-d/pascal-cased-props.ts b/test-d/pascal-cased-props.ts
index cc845eed7..16633a239 100644
--- a/test-d/pascal-cased-props.ts
+++ b/test-d/pascal-cased-props.ts
@@ -1,7 +1,7 @@
-import {PascalCasedProps} from '../ts41/pascal-cased-props';
+import {PascalCasedProperties} from '../ts41/pascal-cased-props';
 import {expectType} from 'tsd';
 
-declare const foo: PascalCasedProps<{ helloWorld: { fooBar: string } }>;
+declare const foo: PascalCasedProperties<{ helloWorld: { fooBar: string } }>;
 expectType<{ HelloWorld: { fooBar: string } }>(foo);
 
 // Verify Example
@@ -9,8 +9,8 @@ interface User {
 	userId: number;
 	userName: string;
 }
-const result: PascalCasedProps<User> = {
+const result: PascalCasedProperties<User> = {
 	UserId: 1,
 	UserName: 'Tom'
 };
-expectType<PascalCasedProps<User>>(result);
+expectType<PascalCasedProperties<User>>(result);
diff --git a/test-d/snake-cased-props-deep.ts b/test-d/snake-cased-props-deep.ts
index d566f2447..6734cbee8 100644
--- a/test-d/snake-cased-props-deep.ts
+++ b/test-d/snake-cased-props-deep.ts
@@ -1,7 +1,7 @@
-import {SnakeCasedPropsDeep} from '../ts41/snake-cased-props-deep';
+import {SnakeCasedPropertiesDeep} from '../ts41/snake-cased-props-deep';
 import {expectType} from 'tsd';
 
-declare const foo: SnakeCasedPropsDeep<{ helloWorld: { fooBar: string } }>;
+declare const foo: SnakeCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
 expectType<{ hello_world: { foo_bar: string } }>(foo);
 
 // Verify Example
@@ -15,7 +15,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: SnakeCasedPropsDeep<UserWithFriends> = {
+const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
 	user_info: {
 		user_id: 1,
 		user_name: 'Tom'
@@ -31,4 +31,4 @@ const result: SnakeCasedPropsDeep<UserWithFriends> = {
 		}
 	]
 };
-expectType<SnakeCasedPropsDeep<UserWithFriends>>(result);
+expectType<SnakeCasedPropertiesDeep<UserWithFriends>>(result);
diff --git a/test-d/snake-cased-props.ts b/test-d/snake-cased-props.ts
index f0460631c..5cb7e2c0f 100644
--- a/test-d/snake-cased-props.ts
+++ b/test-d/snake-cased-props.ts
@@ -1,7 +1,7 @@
-import {SnakeCasedProps} from '../ts41/snake-cased-props';
+import {SnakeCasedProperties} from '../ts41/snake-cased-props';
 import {expectType} from 'tsd';
 
-declare const foo: SnakeCasedProps<{ helloWorld: { fooBar: string } }>;
+declare const foo: SnakeCasedProperties<{ helloWorld: { fooBar: string } }>;
 expectType<{ hello_world: { fooBar: string } }>(foo);
 
 // Verify Example
@@ -9,8 +9,8 @@ interface User {
 	userId: number;
 	userName: string;
 }
-const result: SnakeCasedProps<User> = {
+const result: SnakeCasedProperties<User> = {
 	user_id: 1,
 	user_name: 'Tom'
 };
-expectType<SnakeCasedProps<User>>(result);
+expectType<SnakeCasedProperties<User>>(result);
diff --git a/ts41/camel-case.d.ts b/ts41/camel-case.d.ts
index 4f9a67bc4..7135743d9 100644
--- a/ts41/camel-case.d.ts
+++ b/ts41/camel-case.d.ts
@@ -44,7 +44,7 @@ const someVariable: CamelCase<'foo-bar'> = 'fooBar';
 
 // Advanced
 
-type CamelCasedProps<T> = {
+type CamelCasedProperties<T> = {
 	[K in keyof T as CamelCase<K>]: T[K]
 };
 
@@ -54,7 +54,7 @@ interface RawOptions {
 	foo: number;
 }
 
-const dbResult: CamelCasedProps<ModelProps> = {
+const dbResult: CamelCasedProperties<ModelProps> = {
 	dryRun: true,
 	fullFamilyName: 'bar.js',
 	foo: 123
diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
index 6b18618c1..2fc55d259 100644
--- a/ts41/camel-cased-props-deep.d.ts
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -5,7 +5,7 @@ Convert object props to camelCase recursively.
 
 This can be useful when, for example, converting some API types from other style.
 
-@see CamelCasedProps
+@see CamelCasedProperties
 @see CamelCase
 @example
 ```
@@ -19,7 +19,7 @@ interface UserWithFriends {
     UserFriends: User[];
 }
 
-const result: CamelCasedPropsDeep<UserWithFriends> = {
+const result: CamelCasedPropertiesDeep<UserWithFriends> = {
     userInfo: {
         userId: 1,
         userName: "Tom",
@@ -38,8 +38,8 @@ const result: CamelCasedPropsDeep<UserWithFriends> = {
 
 ```
 */
-export type CamelCasedPropsDeep<T> = T extends Array<infer U>
-	? Array<CamelCasedPropsDeep<U>>
+export type CamelCasedPropertiesDeep<T> = T extends Array<infer U>
+	? Array<CamelCasedPropertiesDeep<U>>
 	: {
-			[K in keyof T as CamelCase<K>]: CamelCasedPropsDeep<T[K]>;
+			[K in keyof T as CamelCase<K>]: CamelCasedPropertiesDeep<T[K]>;
 	};
diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-props.d.ts
index 2d32afc3c..3b6659db5 100644
--- a/ts41/camel-cased-props.d.ts
+++ b/ts41/camel-cased-props.d.ts
@@ -5,7 +5,7 @@ Convert object props to camelCase but not recursively.
 
 This can be useful when, for example, converting some api type from other style.
 
-@see CamelCasedPropsDeep
+@see CamelCasedPropertiesDeep
 @see CamelCase
 @example
 ```
@@ -14,14 +14,14 @@ interface User {
 	UserName: string;
 }
 
-const result: CamelCasedProps<User> = {
+const result: CamelCasedProperties<User> = {
 	userId: 1,
 	userName: "Tom",
 };
 
 ```
 */
-export type CamelCasedProps<T> = T extends Array<infer U>
+export type CamelCasedProperties<T> = T extends Array<infer U>
 	? U[]
 	: {
 			[K in keyof T as CamelCase<K>]: T[K];
diff --git a/ts41/delimiter-case.d.ts b/ts41/delimiter-case.d.ts
index 52f4eb992..a58ed5526 100644
--- a/ts41/delimiter-case.d.ts
+++ b/ts41/delimiter-case.d.ts
@@ -57,7 +57,7 @@ const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
 
 // Advanced
 
-type OddlyCasedProps<T> = {
+type OddlyCasedProperties<T> = {
 	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
 };
 
@@ -67,7 +67,7 @@ interface SomeOptions {
 	foo: number;
 }
 
-const rawCliOptions: OddlyCasedProps<SomeOptions> = {
+const rawCliOptions: OddlyCasedProperties<SomeOptions> = {
 	'dry#run': true,
 	'include#file': 'bar.js',
 	foo: 123
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
index 0adb3761f..677df9c5b 100644
--- a/ts41/delimiter-cased-props-deep.d.ts
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -6,7 +6,7 @@ Convert object props to delimiter-case recursively.
 This can be useful when, for example, converting some API types from other style.
 
 @see DelimiterCase
-@see DelimiterCasedProps
+@see DelimiterCasedProperties
 @example
 ```
 interface User {
@@ -19,7 +19,7 @@ interface UserWithFriends {
     userFriends: User[];
 }
 
-const result: DelimiterCasedPropsDeep<UserWithFriends, '-'> = {
+const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
     'user-info': {
         'user-id': 1,
         'user-name': "Tom",
@@ -38,6 +38,6 @@ const result: DelimiterCasedPropsDeep<UserWithFriends, '-'> = {
 
 ```
 */
-export type DelimiterCasedPropsDeep<T, D extends string> = T extends Array<infer U> ? Array<DelimiterCasedPropsDeep<U, D>> : {
-            [K in keyof T as DelimiterCase<K, D>]: DelimiterCasedPropsDeep<T[K], D>;
+export type DelimiterCasedPropertiesDeep<T, D extends string> = T extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, D>> : {
+            [K in keyof T as DelimiterCase<K, D>]: DelimiterCasedPropertiesDeep<T[K], D>;
       };
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-props.d.ts
index 1d3ae81f8..bf109fd8b 100644
--- a/ts41/delimiter-cased-props.d.ts
+++ b/ts41/delimiter-cased-props.d.ts
@@ -6,19 +6,19 @@ Convert object props to delimiter-case but not recursively.
 This can be useful when, for example, converting some api type from other style.
 
 @see DelimiterCase
-@see DelimiterCasedPropsDeep
+@see DelimiterCasedPropertiesDeep
 @example
 ```
 interface User {
 	userId: number;
 	userName: string;
 }
-const result: DelimiterCasedProps<User, "-"> = {
+const result: DelimiterCasedProperties<User, "-"> = {
 	"user-id": 1,
 	"user-name": "Tom",
 };
 ```
 */
-export type DelimiterCasedProps<T, D extends string> = T extends Array<infer U>
+export type DelimiterCasedProperties<T, D extends string> = T extends Array<infer U>
 	? U[]
 	: { [K in keyof T as DelimiterCase<K, D>]: T[K] };
diff --git a/ts41/kebab-case.d.ts b/ts41/kebab-case.d.ts
index ba6a99d1f..47049c779 100644
--- a/ts41/kebab-case.d.ts
+++ b/ts41/kebab-case.d.ts
@@ -15,7 +15,7 @@ const someVariable: KebabCase<'fooBar'> = 'foo-bar';
 
 // Advanced
 
-type KebabCasedProps<T> = {
+type KebabCasedProperties<T> = {
 	[K in keyof T as KebabCase<K>]: T[K]
 };
 
@@ -25,7 +25,7 @@ interface CliOptions {
 	foo: number;
 }
 
-const rawCliOptions: KebabCasedProps<CliOptions> = {
+const rawCliOptions: KebabCasedProperties<CliOptions> = {
 	'dry-run': true,
 	'include-file': 'bar.js',
 	foo: 123
diff --git a/ts41/kebab-cased-props-deep.d.ts b/ts41/kebab-cased-props-deep.d.ts
index 146bd142a..e51381af8 100644
--- a/ts41/kebab-cased-props-deep.d.ts
+++ b/ts41/kebab-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedPropsDeep} from './delimiter-cased-props-deep';
+import {DelimiterCasedPropertiesDeep} from './delimiter-cased-props-deep';
 
 /**
 Convert object props to kebab-case recursively.
@@ -6,7 +6,7 @@ Convert object props to kebab-case recursively.
 This can be useful when, for example, converting some API types from other style.
 
 @see KebabCase
-@see KebabCasedProps
+@see KebabCasedProperties
 @example
 ```
 interface User {
@@ -19,7 +19,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: KebabCasedPropsDeep<UserWithFriends> = {
+const result: KebabCasedPropertiesDeep<UserWithFriends> = {
 	'user-info': {
 		'user-id': 1,
 		'user-name': "Tom",
@@ -38,4 +38,4 @@ const result: KebabCasedPropsDeep<UserWithFriends> = {
 
 ```
 */
-export type KebabCasedPropsDeep<T> = DelimiterCasedPropsDeep<T, '-'>;
+export type KebabCasedPropertiesDeep<T> = DelimiterCasedPropertiesDeep<T, '-'>;
diff --git a/ts41/kebab-cased-props.d.ts b/ts41/kebab-cased-props.d.ts
index f27222243..a20601d8d 100644
--- a/ts41/kebab-cased-props.d.ts
+++ b/ts41/kebab-cased-props.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedProps} from './delimiter-cased-props';
+import {DelimiterCasedProperties} from './delimiter-cased-props';
 
 /**
 Convert object props to kebab-case but not recursively.
@@ -6,17 +6,17 @@ Convert object props to kebab-case but not recursively.
 This can be useful when, for example, converting some api type from other style.
 
 @see KebabCase
-@see KebabCasedPropsDeep
+@see KebabCasedPropertiesDeep
 @example
 ```
 interface User {
 	userId: number;
 	userName: string;
 }
-const result: KebabCasedProps<User> = {
+const result: KebabCasedProperties<User> = {
 	"user-id": 1,
 	"user-name": "Tom",
 };
 ```
 */
-export type KebabCasedProps<T> = DelimiterCasedProps<T, '-'>;
+export type KebabCasedProperties<T> = DelimiterCasedProperties<T, '-'>;
diff --git a/ts41/pascal-case.d.ts b/ts41/pascal-case.d.ts
index bfb2a3627..35bd2fd18 100644
--- a/ts41/pascal-case.d.ts
+++ b/ts41/pascal-case.d.ts
@@ -23,7 +23,7 @@ interface RawOptions {
 	foo: number;
 }
 
-const dbResult: CamelCasedProps<ModelProps> = {
+const dbResult: CamelCasedProperties<ModelProps> = {
 	DryRun: true,
 	FullFamilyName: 'bar.js',
 	Foo: 123
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-props-deep.d.ts
index 85cd9bca3..63224dcc3 100644
--- a/ts41/pascal-cased-props-deep.d.ts
+++ b/ts41/pascal-cased-props-deep.d.ts
@@ -6,7 +6,7 @@ Convert object props to PascalCase recursively.
 This can be useful when, for example, converting some API types from other style.
 
 @see PascalCase
-@see PascalCasedProps
+@see PascalCasedProperties
 @example
 ```
 interface User {
@@ -19,7 +19,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: PascalCasedPropsDeep<UserWithFriends> = {
+const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 	UserInfo: {
 		UserId: 1,
 		UserName: "Tom",
@@ -37,8 +37,8 @@ const result: PascalCasedPropsDeep<UserWithFriends> = {
 };
 
 */
-export type PascalCasedPropsDeep<T> = T extends Array<infer U>
-	? Array<PascalCasedPropsDeep<U>>
+export type PascalCasedPropertiesDeep<T> = T extends Array<infer U>
+	? Array<PascalCasedPropertiesDeep<U>>
 	: {
-			[K in keyof T as PascalCase<K>]: PascalCasedPropsDeep<T[K]>;
+			[K in keyof T as PascalCase<K>]: PascalCasedPropertiesDeep<T[K]>;
 	};
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-props.d.ts
index 7cb1cf7f0..12031bec9 100644
--- a/ts41/pascal-cased-props.d.ts
+++ b/ts41/pascal-cased-props.d.ts
@@ -6,20 +6,20 @@ Convert object props to PascalCase but not recursively.
 This can be useful when, for example, converting some api type from other style.
 
 @see PascalCase
-@see PascalCasedPropsDeep
+@see PascalCasedPropertiesDeep
 @example
 ```
 interface User {
 	userId: number;
 	userName: string;
 }
-const result: PascalCasedProps<User> = {
+const result: PascalCasedProperties<User> = {
 	UserId: 1,
 	UserName: "Tom",
 };
 
 ```
 */
-export type PascalCasedProps<T> = T extends Array<infer U>
+export type PascalCasedProperties<T> = T extends Array<infer U>
 	? U[]
 	: { [K in keyof T as PascalCase<K>]: T[K] };
diff --git a/ts41/snake-case.d.ts b/ts41/snake-case.d.ts
index 272b3d359..f8efb4bd5 100644
--- a/ts41/snake-case.d.ts
+++ b/ts41/snake-case.d.ts
@@ -15,7 +15,7 @@ const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
 
 // Advanced
 
-type SnakeCasedProps<T> = {
+type SnakeCasedProperties<T> = {
 	[K in keyof T as SnakeCase<K>]: T[K]
 };
 
@@ -25,7 +25,7 @@ interface ModelProps {
 	foo: number;
 }
 
-const dbResult: SnakeCasedProps<ModelProps> = {
+const dbResult: SnakeCasedProperties<ModelProps> = {
 	'is_happy': true,
 	'full_family_name': 'Carla Smith',
 	foo: 123
diff --git a/ts41/snake-cased-props-deep.d.ts b/ts41/snake-cased-props-deep.d.ts
index e8a7a796b..b273112ea 100644
--- a/ts41/snake-cased-props-deep.d.ts
+++ b/ts41/snake-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedPropsDeep} from './delimiter-cased-props-deep';
+import {DelimiterCasedPropertiesDeep} from './delimiter-cased-props-deep';
 
 /**
 Convert object props to snake_case recursively.
@@ -6,7 +6,7 @@ Convert object props to snake_case recursively.
 This can be useful when, for example, converting some API types from other style.
 
 @see SnakeCase
-@see SnakeCasedProps
+@see SnakeCasedProperties
 @example
 ```
 interface User {
@@ -19,7 +19,7 @@ interface UserWithFriends {
 	userFriends: User[];
 }
 
-const result: SnakeCasedPropsDeep<UserWithFriends> = {
+const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
 	user_info: {
 		user_id: 1,
 		user_name: "Tom",
@@ -37,4 +37,4 @@ const result: SnakeCasedPropsDeep<UserWithFriends> = {
 };
 
 */
-export type SnakeCasedPropsDeep<T> = DelimiterCasedPropsDeep<T, '_'>;
+export type SnakeCasedPropertiesDeep<T> = DelimiterCasedPropertiesDeep<T, '_'>;
diff --git a/ts41/snake-cased-props.d.ts b/ts41/snake-cased-props.d.ts
index f92e0c8ef..dab7a2b41 100644
--- a/ts41/snake-cased-props.d.ts
+++ b/ts41/snake-cased-props.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedProps} from './delimiter-cased-props';
+import {DelimiterCasedProperties} from './delimiter-cased-props';
 
 /**
 Convert object props to snake_case but not recursively.
@@ -6,18 +6,18 @@ Convert object props to snake_case but not recursively.
 This can be useful when, for example, converting some api type from other style.
 
 @see SnakeCase
-@see SnakeCasedPropsDeep
+@see SnakeCasedPropertiesDeep
 @example
 ```
 interface User {
 	userId: number;
 	userName: string;
 }
-const result: SnakeCasedProps<User> = {
+const result: SnakeCasedProperties<User> = {
 	user_id: 1,
 	user_name: "Tom",
 };
 
 ```
 */
-export type SnakeCasedProps<T> = DelimiterCasedProps<T, '_'>;
+export type SnakeCasedProperties<T> = DelimiterCasedProperties<T, '_'>;

From 0f824146a32cfab3f50f14d2b937593601fc465d Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:09:01 +0800
Subject: [PATCH 04/41] fix: make all changes single quote

---
 ts41/camel-cased-props-deep.d.ts     | 6 +++---
 ts41/camel-cased-props.d.ts          | 2 +-
 ts41/delimiter-cased-props-deep.d.ts | 6 +++---
 ts41/delimiter-cased-props.d.ts      | 6 +++---
 ts41/kebab-cased-props-deep.d.ts     | 6 +++---
 ts41/kebab-cased-props.d.ts          | 4 ++--
 ts41/pascal-cased-props-deep.d.ts    | 6 +++---
 ts41/pascal-cased-props.d.ts         | 2 +-
 ts41/snake-cased-props-deep.d.ts     | 6 +++---
 ts41/snake-cased-props.d.ts          | 2 +-
 10 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
index 2fc55d259..c3e2f4fb1 100644
--- a/ts41/camel-cased-props-deep.d.ts
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -22,16 +22,16 @@ interface UserWithFriends {
 const result: CamelCasedPropertiesDeep<UserWithFriends> = {
     userInfo: {
         userId: 1,
-        userName: "Tom",
+        userName: 'Tom',
     },
     userFriends: [
         {
             userId: 2,
-            userName: "Jerry",
+            userName: 'Jerry',
         },
         {
             userId: 3,
-            userName: "Spike",
+            userName: 'Spike',
         },
     ],
 };
diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-props.d.ts
index 3b6659db5..28b50978c 100644
--- a/ts41/camel-cased-props.d.ts
+++ b/ts41/camel-cased-props.d.ts
@@ -16,7 +16,7 @@ interface User {
 
 const result: CamelCasedProperties<User> = {
 	userId: 1,
-	userName: "Tom",
+	userName: 'Tom',
 };
 
 ```
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
index 677df9c5b..fbe042d7f 100644
--- a/ts41/delimiter-cased-props-deep.d.ts
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -22,16 +22,16 @@ interface UserWithFriends {
 const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
     'user-info': {
         'user-id': 1,
-        'user-name': "Tom",
+        'user-name': 'Tom',
     },
     'user-friends': [
         {
             'user-id': 2,
-            'user-name': "Jerry",
+            'user-name': 'Jerry',
         },
         {
             'user-id': 3,
-            'user-name': "Spike",
+            'user-name': 'Spike',
         },
     ],
 };
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-props.d.ts
index bf109fd8b..2a29f0aa3 100644
--- a/ts41/delimiter-cased-props.d.ts
+++ b/ts41/delimiter-cased-props.d.ts
@@ -13,9 +13,9 @@ interface User {
 	userId: number;
 	userName: string;
 }
-const result: DelimiterCasedProperties<User, "-"> = {
-	"user-id": 1,
-	"user-name": "Tom",
+const result: DelimiterCasedProperties<User, '-'> = {
+	'user-id': 1,
+	'user-name': 'Tom',
 };
 ```
 */
diff --git a/ts41/kebab-cased-props-deep.d.ts b/ts41/kebab-cased-props-deep.d.ts
index e51381af8..b2a84ddf9 100644
--- a/ts41/kebab-cased-props-deep.d.ts
+++ b/ts41/kebab-cased-props-deep.d.ts
@@ -22,16 +22,16 @@ interface UserWithFriends {
 const result: KebabCasedPropertiesDeep<UserWithFriends> = {
 	'user-info': {
 		'user-id': 1,
-		'user-name': "Tom",
+		'user-name': 'Tom',
 	},
 	'user-friends': [
 		{
 			'user-id': 2,
-			'user-name': "Jerry",
+			'user-name': 'Jerry',
 		},
 		{
 			'user-id': 3,
-			'user-name': "Spike",
+			'user-name': 'Spike',
 		},
 	],
 };
diff --git a/ts41/kebab-cased-props.d.ts b/ts41/kebab-cased-props.d.ts
index a20601d8d..4d3b3455c 100644
--- a/ts41/kebab-cased-props.d.ts
+++ b/ts41/kebab-cased-props.d.ts
@@ -14,8 +14,8 @@ interface User {
 	userName: string;
 }
 const result: KebabCasedProperties<User> = {
-	"user-id": 1,
-	"user-name": "Tom",
+	'user-id': 1,
+	'user-name': 'Tom',
 };
 ```
 */
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-props-deep.d.ts
index 63224dcc3..859ce5d1f 100644
--- a/ts41/pascal-cased-props-deep.d.ts
+++ b/ts41/pascal-cased-props-deep.d.ts
@@ -22,16 +22,16 @@ interface UserWithFriends {
 const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 	UserInfo: {
 		UserId: 1,
-		UserName: "Tom",
+		UserName: 'Tom',
 	},
 	UserFriends: [
 		{
 			UserId: 2,
-			UserName: "Jerry",
+			UserName: 'Jerry',
 		},
 		{
 			UserId: 3,
-			UserName: "Spike",
+			UserName: 'Spike',
 		},
 	],
 };
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-props.d.ts
index 12031bec9..058932658 100644
--- a/ts41/pascal-cased-props.d.ts
+++ b/ts41/pascal-cased-props.d.ts
@@ -15,7 +15,7 @@ interface User {
 }
 const result: PascalCasedProperties<User> = {
 	UserId: 1,
-	UserName: "Tom",
+	UserName: 'Tom',
 };
 
 ```
diff --git a/ts41/snake-cased-props-deep.d.ts b/ts41/snake-cased-props-deep.d.ts
index b273112ea..f12d58ed7 100644
--- a/ts41/snake-cased-props-deep.d.ts
+++ b/ts41/snake-cased-props-deep.d.ts
@@ -22,16 +22,16 @@ interface UserWithFriends {
 const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
 	user_info: {
 		user_id: 1,
-		user_name: "Tom",
+		user_name: 'Tom',
 	},
 	user_friends: [
 		{
 			user_id: 2,
-			user_name: "Jerry",
+			user_name: 'Jerry',
 		},
 		{
 			user_id: 3,
-			user_name: "Spike",
+			user_name: 'Spike',
 		},
 	],
 };
diff --git a/ts41/snake-cased-props.d.ts b/ts41/snake-cased-props.d.ts
index dab7a2b41..8e5583827 100644
--- a/ts41/snake-cased-props.d.ts
+++ b/ts41/snake-cased-props.d.ts
@@ -15,7 +15,7 @@ interface User {
 }
 const result: SnakeCasedProperties<User> = {
 	user_id: 1,
-	user_name: "Tom",
+	user_name: 'Tom',
 };
 
 ```

From 46ecc079791ab54b9ec87d77d65caabbed08f389 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:16:31 +0800
Subject: [PATCH 05/41] fix: return original type when non-deep converting
 array

---
 ts41/camel-cased-props.d.ts     | 6 +++---
 ts41/delimiter-cased-props.d.ts | 6 +++---
 ts41/kebab-cased-props.d.ts     | 2 +-
 ts41/pascal-cased-props.d.ts    | 6 +++---
 ts41/snake-cased-props.d.ts     | 2 +-
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-props.d.ts
index 28b50978c..63f10bc55 100644
--- a/ts41/camel-cased-props.d.ts
+++ b/ts41/camel-cased-props.d.ts
@@ -21,8 +21,8 @@ const result: CamelCasedProperties<User> = {
 
 ```
 */
-export type CamelCasedProperties<T> = T extends Array<infer U>
-	? U[]
+export type CamelCasedProperties<Value> = Value extends Array<infer U>
+	? Value
 	: {
-			[K in keyof T as CamelCase<K>]: T[K];
+			[K in keyof Value as CamelCase<K>]: Value[K];
 	};
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-props.d.ts
index 2a29f0aa3..8b3582106 100644
--- a/ts41/delimiter-cased-props.d.ts
+++ b/ts41/delimiter-cased-props.d.ts
@@ -19,6 +19,6 @@ const result: DelimiterCasedProperties<User, '-'> = {
 };
 ```
 */
-export type DelimiterCasedProperties<T, D extends string> = T extends Array<infer U>
-	? U[]
-	: { [K in keyof T as DelimiterCase<K, D>]: T[K] };
+export type DelimiterCasedProperties<Value, Delimiter extends string> = Value extends Array<infer U>
+	? Value
+	: { [K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K] };
diff --git a/ts41/kebab-cased-props.d.ts b/ts41/kebab-cased-props.d.ts
index 4d3b3455c..5ce507775 100644
--- a/ts41/kebab-cased-props.d.ts
+++ b/ts41/kebab-cased-props.d.ts
@@ -19,4 +19,4 @@ const result: KebabCasedProperties<User> = {
 };
 ```
 */
-export type KebabCasedProperties<T> = DelimiterCasedProperties<T, '-'>;
+export type KebabCasedProperties<Value> = DelimiterCasedProperties<Value, '-'>;
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-props.d.ts
index 058932658..a13a2254f 100644
--- a/ts41/pascal-cased-props.d.ts
+++ b/ts41/pascal-cased-props.d.ts
@@ -20,6 +20,6 @@ const result: PascalCasedProperties<User> = {
 
 ```
 */
-export type PascalCasedProperties<T> = T extends Array<infer U>
-	? U[]
-	: { [K in keyof T as PascalCase<K>]: T[K] };
+export type PascalCasedProperties<Value> = Value extends Array<infer U>
+	? Value
+	: { [K in keyof Value as PascalCase<K>]: Value[K] };
diff --git a/ts41/snake-cased-props.d.ts b/ts41/snake-cased-props.d.ts
index 8e5583827..6f1343a16 100644
--- a/ts41/snake-cased-props.d.ts
+++ b/ts41/snake-cased-props.d.ts
@@ -20,4 +20,4 @@ const result: SnakeCasedProperties<User> = {
 
 ```
 */
-export type SnakeCasedProperties<T> = DelimiterCasedProperties<T, '_'>;
+export type SnakeCasedProperties<Value> = DelimiterCasedProperties<Value, '_'>;

From 4c0c208d594cce0703ff43629127fd72e713bac4 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:18:04 +0800
Subject: [PATCH 06/41] fix: use descriptive type name

---
 ts41/camel-cased-props-deep.d.ts     | 4 ++--
 ts41/delimiter-cased-props-deep.d.ts | 4 ++--
 ts41/kebab-cased-props-deep.d.ts     | 2 +-
 ts41/pascal-cased-props-deep.d.ts    | 4 ++--
 ts41/snake-cased-props-deep.d.ts     | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
index c3e2f4fb1..4befa084d 100644
--- a/ts41/camel-cased-props-deep.d.ts
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -38,8 +38,8 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 
 ```
 */
-export type CamelCasedPropertiesDeep<T> = T extends Array<infer U>
+export type CamelCasedPropertiesDeep<Value> = Value extends Array<infer U>
 	? Array<CamelCasedPropertiesDeep<U>>
 	: {
-			[K in keyof T as CamelCase<K>]: CamelCasedPropertiesDeep<T[K]>;
+			[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
 	};
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
index fbe042d7f..948b5c1b9 100644
--- a/ts41/delimiter-cased-props-deep.d.ts
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -38,6 +38,6 @@ const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 
 ```
 */
-export type DelimiterCasedPropertiesDeep<T, D extends string> = T extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, D>> : {
-            [K in keyof T as DelimiterCase<K, D>]: DelimiterCasedPropertiesDeep<T[K], D>;
+export type DelimiterCasedPropertiesDeep<Value, Delimiter extends string> = Value extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
+            [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
       };
diff --git a/ts41/kebab-cased-props-deep.d.ts b/ts41/kebab-cased-props-deep.d.ts
index b2a84ddf9..52d5e690c 100644
--- a/ts41/kebab-cased-props-deep.d.ts
+++ b/ts41/kebab-cased-props-deep.d.ts
@@ -38,4 +38,4 @@ const result: KebabCasedPropertiesDeep<UserWithFriends> = {
 
 ```
 */
-export type KebabCasedPropertiesDeep<T> = DelimiterCasedPropertiesDeep<T, '-'>;
+export type KebabCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '-'>;
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-props-deep.d.ts
index 859ce5d1f..b6162d14b 100644
--- a/ts41/pascal-cased-props-deep.d.ts
+++ b/ts41/pascal-cased-props-deep.d.ts
@@ -37,8 +37,8 @@ const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 };
 
 */
-export type PascalCasedPropertiesDeep<T> = T extends Array<infer U>
+export type PascalCasedPropertiesDeep<Value> = Value extends Array<infer U>
 	? Array<PascalCasedPropertiesDeep<U>>
 	: {
-			[K in keyof T as PascalCase<K>]: PascalCasedPropertiesDeep<T[K]>;
+			[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
 	};
diff --git a/ts41/snake-cased-props-deep.d.ts b/ts41/snake-cased-props-deep.d.ts
index f12d58ed7..5f21f5447 100644
--- a/ts41/snake-cased-props-deep.d.ts
+++ b/ts41/snake-cased-props-deep.d.ts
@@ -37,4 +37,4 @@ const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
 };
 
 */
-export type SnakeCasedPropertiesDeep<T> = DelimiterCasedPropertiesDeep<T, '_'>;
+export type SnakeCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '_'>;

From f32e25d323398969d39a9391b9f356e6d4e71a48 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:19:56 +0800
Subject: [PATCH 07/41] chore: use tab indention

---
 ts41/camel-cased-props-deep.d.ts     | 38 ++++++++++----------
 ts41/delimiter-cased-props-deep.d.ts | 52 ++++++++++++++++------------
 2 files changed, 49 insertions(+), 41 deletions(-)

diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
index 4befa084d..57482b74d 100644
--- a/ts41/camel-cased-props-deep.d.ts
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import {CamelCase} from './camel-case';
+import { CamelCase } from "./camel-case";
 
 /**
 Convert object props to camelCase recursively.
@@ -10,30 +10,30 @@ This can be useful when, for example, converting some API types from other style
 @example
 ```
 interface User {
-    UserId: number;
-    UserName: string;
+	UserId: number;
+	UserName: string;
 }
 
 interface UserWithFriends {
-    UserInfo: User;
-    UserFriends: User[];
+	UserInfo: User;
+	UserFriends: User[];
 }
 
 const result: CamelCasedPropertiesDeep<UserWithFriends> = {
-    userInfo: {
-        userId: 1,
-        userName: 'Tom',
-    },
-    userFriends: [
-        {
-            userId: 2,
-            userName: 'Jerry',
-        },
-        {
-            userId: 3,
-            userName: 'Spike',
-        },
-    ],
+	userInfo: {
+		userId: 1,
+		userName: 'Tom',
+	},
+	userFriends: [
+		{
+			userId: 2,
+			userName: 'Jerry',
+		},
+		{
+			userId: 3,
+			userName: 'Spike',
+		},
+	],
 };
 
 ```
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
index 948b5c1b9..e28cef985 100644
--- a/ts41/delimiter-cased-props-deep.d.ts
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCase} from './delimiter-case';
+import { DelimiterCase } from "./delimiter-case";
 
 /**
 Convert object props to delimiter-case recursively.
@@ -10,34 +10,42 @@ This can be useful when, for example, converting some API types from other style
 @example
 ```
 interface User {
-    userId: number;
-    userName: string;
+	userId: number;
+	userName: string;
 }
 
 interface UserWithFriends {
-    userInfo: User;
-    userFriends: User[];
+	userInfo: User;
+	userFriends: User[];
 }
 
 const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
-    'user-info': {
-        'user-id': 1,
-        'user-name': 'Tom',
-    },
-    'user-friends': [
-        {
-            'user-id': 2,
-            'user-name': 'Jerry',
-        },
-        {
-            'user-id': 3,
-            'user-name': 'Spike',
-        },
-    ],
+	'user-info': {
+	'user-id': 1,
+		'user-name': 'Tom',
+	},
+	'user-friends': [
+		{
+			'user-id': 2,
+			'user-name': 'Jerry',
+		},
+		{
+			'user-id': 3,
+			'user-name': 'Spike',
+		},
+	],
 };
 
 ```
 */
-export type DelimiterCasedPropertiesDeep<Value, Delimiter extends string> = Value extends Array<infer U> ? Array<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
-            [K in keyof Value as DelimiterCase<K, Delimiter>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
-      };
+export type DelimiterCasedPropertiesDeep<
+	Value,
+	Delimiter extends string
+> = Value extends Array<infer U>
+	? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
+	: {
+			[K in keyof Value as DelimiterCase<
+				K,
+				Delimiter
+			>]: DelimiterCasedPropertiesDeep<Value[K], Delimiter>;
+	};

From fc60ee0a371f483adf5d0ff17f1e39a29204d3a2 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:23:03 +0800
Subject: [PATCH 08/41] fix: add judgement for function

---
 ts41/camel-cased-props-deep.d.ts     | 6 ++++--
 ts41/camel-cased-props.d.ts          | 8 +++++---
 ts41/delimiter-cased-props-deep.d.ts | 4 +++-
 ts41/delimiter-cased-props.d.ts      | 9 +++++++--
 ts41/pascal-cased-props-deep.d.ts    | 8 +++++---
 ts41/pascal-cased-props.d.ts         | 6 ++++--
 6 files changed, 28 insertions(+), 13 deletions(-)

diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
index 57482b74d..8334a60b7 100644
--- a/ts41/camel-cased-props-deep.d.ts
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -38,8 +38,10 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 
 ```
 */
-export type CamelCasedPropertiesDeep<Value> = Value extends Array<infer U>
+export type CamelCasedPropertiesDeep<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
 	? Array<CamelCasedPropertiesDeep<U>>
 	: {
 			[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
-	};
+	  };
diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-props.d.ts
index 63f10bc55..6d20c6819 100644
--- a/ts41/camel-cased-props.d.ts
+++ b/ts41/camel-cased-props.d.ts
@@ -1,4 +1,4 @@
-import {CamelCase} from './camel-case';
+import { CamelCase } from "./camel-case";
 
 /**
 Convert object props to camelCase but not recursively.
@@ -21,8 +21,10 @@ const result: CamelCasedProperties<User> = {
 
 ```
 */
-export type CamelCasedProperties<Value> = Value extends Array<infer U>
+export type CamelCasedProperties<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
 	? Value
 	: {
 			[K in keyof Value as CamelCase<K>]: Value[K];
-	};
+	  };
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
index e28cef985..bfcdfe5dd 100644
--- a/ts41/delimiter-cased-props-deep.d.ts
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -41,7 +41,9 @@ const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 export type DelimiterCasedPropertiesDeep<
 	Value,
 	Delimiter extends string
-> = Value extends Array<infer U>
+> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
 	? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
 	: {
 			[K in keyof Value as DelimiterCase<
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-props.d.ts
index 8b3582106..46acc600c 100644
--- a/ts41/delimiter-cased-props.d.ts
+++ b/ts41/delimiter-cased-props.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCase} from './delimiter-case';
+import { DelimiterCase } from "./delimiter-case";
 
 /**
 Convert object props to delimiter-case but not recursively.
@@ -19,6 +19,11 @@ const result: DelimiterCasedProperties<User, '-'> = {
 };
 ```
 */
-export type DelimiterCasedProperties<Value, Delimiter extends string> = Value extends Array<infer U>
+export type DelimiterCasedProperties<
+	Value,
+	Delimiter extends string
+> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
 	? Value
 	: { [K in keyof Value as DelimiterCase<K, Delimiter>]: Value[K] };
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-props-deep.d.ts
index b6162d14b..cc475c7af 100644
--- a/ts41/pascal-cased-props-deep.d.ts
+++ b/ts41/pascal-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import {PascalCase} from './pascal-case';
+import { PascalCase } from "./pascal-case";
 
 /**
 Convert object props to PascalCase recursively.
@@ -37,8 +37,10 @@ const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 };
 
 */
-export type PascalCasedPropertiesDeep<Value> = Value extends Array<infer U>
+export type PascalCasedPropertiesDeep<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
 	? Array<PascalCasedPropertiesDeep<U>>
 	: {
 			[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
-	};
+	  };
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-props.d.ts
index a13a2254f..1d92d37e6 100644
--- a/ts41/pascal-cased-props.d.ts
+++ b/ts41/pascal-cased-props.d.ts
@@ -1,4 +1,4 @@
-import {PascalCase} from './pascal-case';
+import { PascalCase } from "./pascal-case";
 
 /**
 Convert object props to PascalCase but not recursively.
@@ -20,6 +20,8 @@ const result: PascalCasedProperties<User> = {
 
 ```
 */
-export type PascalCasedProperties<Value> = Value extends Array<infer U>
+export type PascalCasedProperties<Value> = Value extends Function
+	? Value
+	: Value extends Array<infer U>
 	? Value
 	: { [K in keyof Value as PascalCase<K>]: Value[K] };

From 4c3442259ed09e2f83e4a6fed0c9318a425a00f7 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:27:38 +0800
Subject: [PATCH 09/41] fix: add test for function

---
 test-d/camel-cased-props-deep.ts     | 3 +++
 test-d/camel-cased-props.ts          | 7 +++++++
 test-d/delimiter-cased-props-deep.ts | 3 +++
 test-d/delimiter-cased-props.ts      | 6 ++++++
 test-d/pascal-cased-props-deep.ts    | 3 +++
 test-d/pascal-cased-props.ts         | 7 +++++++
 6 files changed, 29 insertions(+)

diff --git a/test-d/camel-cased-props-deep.ts b/test-d/camel-cased-props-deep.ts
index 7d433ca84..a2df02775 100644
--- a/test-d/camel-cased-props-deep.ts
+++ b/test-d/camel-cased-props-deep.ts
@@ -7,6 +7,9 @@ declare const foo: CamelCasedPropertiesDeep<{
 
 expectType<{ a: { b: number; c: Array<{ d: string }> } }>(foo);
 
+declare const fooBar: CamelCasedPropertiesDeep<() => {a: string}>;
+expectType<() => {a: string}>(fooBar);
+
 // Verify Example
 interface User {
 	UserId: number;
diff --git a/test-d/camel-cased-props.ts b/test-d/camel-cased-props.ts
index 0b4b77b0a..d3477c90f 100644
--- a/test-d/camel-cased-props.ts
+++ b/test-d/camel-cased-props.ts
@@ -10,6 +10,13 @@ declare const foo: CamelCasedProperties<{
 
 expectType<{ a: number; b: { C: string } }>(foo);
 
+declare const bar: CamelCasedProperties<{helloWorld: string}[]>;
+expectType<{helloWorld: string}[]>(bar);
+
+declare const fooBar: CamelCasedProperties<() => {a: string}>;
+expectType<() => {a: string}>(fooBar);
+
+
 // Verify Example
 interface User {
 	UserId: number;
diff --git a/test-d/delimiter-cased-props-deep.ts b/test-d/delimiter-cased-props-deep.ts
index 33cf99a21..0bac2d55a 100644
--- a/test-d/delimiter-cased-props-deep.ts
+++ b/test-d/delimiter-cased-props-deep.ts
@@ -4,6 +4,9 @@ import {DelimiterCasedPropertiesDeep} from '../ts41/delimiter-cased-props-deep';
 declare const foo: DelimiterCasedPropertiesDeep<{helloWorld: {fooBar: string}}, '/'>;
 expectType<{'hello/world': {'foo/bar': string}}>(foo);
 
+declare const fooBar: DelimiterCasedPropertiesDeep<() => {a: string}, '/'>;
+expectType<() => {a: string}>(fooBar);
+
 // Verify Example
 interface User {
 	userId: number;
diff --git a/test-d/delimiter-cased-props.ts b/test-d/delimiter-cased-props.ts
index 529739c8d..10201c9c6 100644
--- a/test-d/delimiter-cased-props.ts
+++ b/test-d/delimiter-cased-props.ts
@@ -4,6 +4,12 @@ import {DelimiterCasedProperties} from '../ts41/delimiter-cased-props';
 declare const foo: DelimiterCasedProperties<{ helloWorld: { fooBar: string } }, '/'>;
 expectType<{ 'hello/world': { fooBar: string } }>(foo);
 
+declare const bar: DelimiterCasedProperties<{helloWorld: string}[], '-'>;
+expectType<{helloWorld: string}[]>(bar);
+
+declare const fooBar: DelimiterCasedProperties<() => {a: string}, '-'>;
+expectType<() => {a: string}>(fooBar);
+
 // Verify Example
 interface User {
 	userId: number;
diff --git a/test-d/pascal-cased-props-deep.ts b/test-d/pascal-cased-props-deep.ts
index e44b9a952..92bb6668b 100644
--- a/test-d/pascal-cased-props-deep.ts
+++ b/test-d/pascal-cased-props-deep.ts
@@ -4,6 +4,9 @@ import {expectType} from 'tsd';
 declare const foo: PascalCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
 expectType<{ HelloWorld: { FooBar: string } }>(foo);
 
+declare const fooBar: PascalCasedPropertiesDeep<() => {a: string}>;
+expectType<() => {a: string}>(fooBar);
+
 // Verify Example
 interface User {
 	userId: number;
diff --git a/test-d/pascal-cased-props.ts b/test-d/pascal-cased-props.ts
index 16633a239..64a02fda0 100644
--- a/test-d/pascal-cased-props.ts
+++ b/test-d/pascal-cased-props.ts
@@ -4,6 +4,13 @@ import {expectType} from 'tsd';
 declare const foo: PascalCasedProperties<{ helloWorld: { fooBar: string } }>;
 expectType<{ HelloWorld: { fooBar: string } }>(foo);
 
+
+declare const bar: PascalCasedProperties<{helloWorld: string}[]>;
+expectType<{helloWorld: string}[]>(bar);
+
+declare const fooBar: PascalCasedProperties<() => {a: string}>;
+expectType<() => {a: string}>(fooBar);
+
 // Verify Example
 interface User {
 	userId: number;

From 9229a2f5d6b1953acaacc3a7df37043b13356dfe Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:28:31 +0800
Subject: [PATCH 10/41] chore: fix lint problem

---
 test-d/camel-cased-props.ts          | 5 ++---
 test-d/delimiter-cased-props.ts      | 4 ++--
 test-d/pascal-cased-props.ts         | 5 ++---
 ts41/camel-cased-props-deep.d.ts     | 4 ++--
 ts41/camel-cased-props.d.ts          | 4 ++--
 ts41/delimiter-cased-props-deep.d.ts | 2 +-
 ts41/delimiter-cased-props.d.ts      | 2 +-
 ts41/pascal-cased-props-deep.d.ts    | 4 ++--
 ts41/pascal-cased-props.d.ts         | 2 +-
 9 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/test-d/camel-cased-props.ts b/test-d/camel-cased-props.ts
index d3477c90f..3a4f41af9 100644
--- a/test-d/camel-cased-props.ts
+++ b/test-d/camel-cased-props.ts
@@ -10,13 +10,12 @@ declare const foo: CamelCasedProperties<{
 
 expectType<{ a: number; b: { C: string } }>(foo);
 
-declare const bar: CamelCasedProperties<{helloWorld: string}[]>;
-expectType<{helloWorld: string}[]>(bar);
+declare const bar: CamelCasedProperties<Array<{helloWorld: string}>>;
+expectType<Array<{helloWorld: string}>>(bar);
 
 declare const fooBar: CamelCasedProperties<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
-
 // Verify Example
 interface User {
 	UserId: number;
diff --git a/test-d/delimiter-cased-props.ts b/test-d/delimiter-cased-props.ts
index 10201c9c6..7657c7c98 100644
--- a/test-d/delimiter-cased-props.ts
+++ b/test-d/delimiter-cased-props.ts
@@ -4,8 +4,8 @@ import {DelimiterCasedProperties} from '../ts41/delimiter-cased-props';
 declare const foo: DelimiterCasedProperties<{ helloWorld: { fooBar: string } }, '/'>;
 expectType<{ 'hello/world': { fooBar: string } }>(foo);
 
-declare const bar: DelimiterCasedProperties<{helloWorld: string}[], '-'>;
-expectType<{helloWorld: string}[]>(bar);
+declare const bar: DelimiterCasedProperties<Array<{helloWorld: string}>, '-'>;
+expectType<Array<{helloWorld: string}>>(bar);
 
 declare const fooBar: DelimiterCasedProperties<() => {a: string}, '-'>;
 expectType<() => {a: string}>(fooBar);
diff --git a/test-d/pascal-cased-props.ts b/test-d/pascal-cased-props.ts
index 64a02fda0..d4f980fb2 100644
--- a/test-d/pascal-cased-props.ts
+++ b/test-d/pascal-cased-props.ts
@@ -4,9 +4,8 @@ import {expectType} from 'tsd';
 declare const foo: PascalCasedProperties<{ helloWorld: { fooBar: string } }>;
 expectType<{ HelloWorld: { fooBar: string } }>(foo);
 
-
-declare const bar: PascalCasedProperties<{helloWorld: string}[]>;
-expectType<{helloWorld: string}[]>(bar);
+declare const bar: PascalCasedProperties<Array<{helloWorld: string}>>;
+expectType<Array<{helloWorld: string}>>(bar);
 
 declare const fooBar: PascalCasedProperties<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-props-deep.d.ts
index 8334a60b7..af3f874f6 100644
--- a/ts41/camel-cased-props-deep.d.ts
+++ b/ts41/camel-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import { CamelCase } from "./camel-case";
+import {CamelCase} from './camel-case';
 
 /**
 Convert object props to camelCase recursively.
@@ -44,4 +44,4 @@ export type CamelCasedPropertiesDeep<Value> = Value extends Function
 	? Array<CamelCasedPropertiesDeep<U>>
 	: {
 			[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
-	  };
+	};
diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-props.d.ts
index 6d20c6819..89f8e131a 100644
--- a/ts41/camel-cased-props.d.ts
+++ b/ts41/camel-cased-props.d.ts
@@ -1,4 +1,4 @@
-import { CamelCase } from "./camel-case";
+import {CamelCase} from './camel-case';
 
 /**
 Convert object props to camelCase but not recursively.
@@ -27,4 +27,4 @@ export type CamelCasedProperties<Value> = Value extends Function
 	? Value
 	: {
 			[K in keyof Value as CamelCase<K>]: Value[K];
-	  };
+	};
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-props-deep.d.ts
index bfcdfe5dd..4f3c1a43b 100644
--- a/ts41/delimiter-cased-props-deep.d.ts
+++ b/ts41/delimiter-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import { DelimiterCase } from "./delimiter-case";
+import {DelimiterCase} from './delimiter-case';
 
 /**
 Convert object props to delimiter-case recursively.
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-props.d.ts
index 46acc600c..c2529c966 100644
--- a/ts41/delimiter-cased-props.d.ts
+++ b/ts41/delimiter-cased-props.d.ts
@@ -1,4 +1,4 @@
-import { DelimiterCase } from "./delimiter-case";
+import {DelimiterCase} from './delimiter-case';
 
 /**
 Convert object props to delimiter-case but not recursively.
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-props-deep.d.ts
index cc475c7af..509e478cd 100644
--- a/ts41/pascal-cased-props-deep.d.ts
+++ b/ts41/pascal-cased-props-deep.d.ts
@@ -1,4 +1,4 @@
-import { PascalCase } from "./pascal-case";
+import {PascalCase} from './pascal-case';
 
 /**
 Convert object props to PascalCase recursively.
@@ -43,4 +43,4 @@ export type PascalCasedPropertiesDeep<Value> = Value extends Function
 	? Array<PascalCasedPropertiesDeep<U>>
 	: {
 			[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
-	  };
+	};
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-props.d.ts
index 1d92d37e6..a0fa79e3d 100644
--- a/ts41/pascal-cased-props.d.ts
+++ b/ts41/pascal-cased-props.d.ts
@@ -1,4 +1,4 @@
-import { PascalCase } from "./pascal-case";
+import {PascalCase} from './pascal-case';
 
 /**
 Convert object props to PascalCase but not recursively.

From a344d2267b613d43e332e1af5f3254f180e15f9f Mon Sep 17 00:00:00 2001
From: wwwzbwcom <zbwhome@outlook.com>
Date: Sun, 7 Feb 2021 11:32:15 +0800
Subject: [PATCH 11/41] chore: rename file names

---
 readme.md                                     | 20 +++++++++----------
 ...deep.ts => camel-cased-properties-deep.ts} |  2 +-
 ...sed-props.ts => camel-cased-properties.ts} |  2 +-
 ....ts => delimiter-cased-properties-deep.ts} |  2 +-
 ...props.ts => delimiter-cased-properties.ts} |  2 +-
 ...deep.ts => kebab-cased-properties-deep.ts} |  2 +-
 ...sed-props.ts => kebab-cased-properties.ts} |  2 +-
 ...eep.ts => pascal-cased-properties-deep.ts} |  2 +-
 ...ed-props.ts => pascal-cased-properties.ts} |  2 +-
 ...deep.ts => snake-cased-properties-deep.ts} |  2 +-
 ...sed-props.ts => snake-cased-properties.ts} |  2 +-
 ....d.ts => camel-cased-properties-deep.d.ts} |  0
 ...props.d.ts => camel-cased-properties.d.ts} |  0
 ...s => delimiter-cased-properties-deep.d.ts} |  0
 ...s.d.ts => delimiter-cased-properties.d.ts} |  0
 ....d.ts => kebab-cased-properties-deep.d.ts} |  2 +-
 ...props.d.ts => kebab-cased-properties.d.ts} |  2 +-
 ...d.ts => pascal-cased-properties-deep.d.ts} |  0
 ...rops.d.ts => pascal-cased-properties.d.ts} |  0
 ....d.ts => snake-cased-properties-deep.d.ts} |  2 +-
 ...props.d.ts => snake-cased-properties.d.ts} |  2 +-
 21 files changed, 24 insertions(+), 24 deletions(-)
 rename test-d/{camel-cased-props-deep.ts => camel-cased-properties-deep.ts} (98%)
 rename test-d/{camel-cased-props.ts => camel-cased-properties.ts} (89%)
 rename test-d/{delimiter-cased-props-deep.ts => delimiter-cased-properties-deep.ts} (97%)
 rename test-d/{delimiter-cased-props.ts => delimiter-cased-properties.ts} (98%)
 rename test-d/{kebab-cased-props-deep.ts => kebab-cased-properties-deep.ts} (97%)
 rename test-d/{kebab-cased-props.ts => kebab-cased-properties.ts} (84%)
 rename test-d/{pascal-cased-props-deep.ts => pascal-cased-properties-deep.ts} (97%)
 rename test-d/{pascal-cased-props.ts => pascal-cased-properties.ts} (89%)
 rename test-d/{snake-cased-props-deep.ts => snake-cased-properties-deep.ts} (97%)
 rename test-d/{snake-cased-props.ts => snake-cased-properties.ts} (84%)
 rename ts41/{camel-cased-props-deep.d.ts => camel-cased-properties-deep.d.ts} (100%)
 rename ts41/{camel-cased-props.d.ts => camel-cased-properties.d.ts} (100%)
 rename ts41/{delimiter-cased-props-deep.d.ts => delimiter-cased-properties-deep.d.ts} (100%)
 rename ts41/{delimiter-cased-props.d.ts => delimiter-cased-properties.d.ts} (100%)
 rename ts41/{kebab-cased-props-deep.d.ts => kebab-cased-properties-deep.d.ts} (97%)
 rename ts41/{kebab-cased-props.d.ts => kebab-cased-properties.d.ts} (85%)
 rename ts41/{pascal-cased-props-deep.d.ts => pascal-cased-properties-deep.d.ts} (100%)
 rename ts41/{pascal-cased-props.d.ts => pascal-cased-properties.d.ts} (100%)
 rename ts41/{snake-cased-props-deep.d.ts => snake-cased-properties-deep.d.ts} (97%)
 rename ts41/{snake-cased-props.d.ts => snake-cased-properties.d.ts} (85%)

diff --git a/readme.md b/readme.md
index a8716c5bd..0366741dd 100644
--- a/readme.md
+++ b/readme.md
@@ -110,24 +110,24 @@ Click the type names for complete docs.
 *Note:* These require [TypeScript 4.1 or newer](https://devblogs.microsoft.com/typescript/announcing-typescript-4-1/#template-literal-types).
 
 - [`CamelCase`](ts41/camel-case.d.ts) – Convert a string literal to camel-case (`fooBar`).
-- [`CamelCasedProperties`](ts41/camel-cased-props.d.ts) – Convert object props to camel-case  (`fooBar`).
-- [`CamelCasedPropertiesDeep`](ts41/camel-cased-props-deep.d.ts) – Convert object props to camel-case recursively  (`fooBar`).
+- [`CamelCasedProperties`](ts41/camel-cased-properties.d.ts) – Convert object properties to camel-case  (`fooBar`).
+- [`CamelCasedPropertiesDeep`](ts41/camel-cased-properties-deep.d.ts) – Convert object properties to camel-case recursively  (`fooBar`).
 
 - [`KebabCase`](ts41/kebab-case.d.ts) – Convert a string literal to kebab-case (`foo-bar`).
-- [`KebabCasedProperties`](ts41/kebab-cased-props.d.ts) – Convert a object props to kebab-case recursively (`foo-bar`).
-- [`KebabCasedPropertiesDeep`](ts41/kebab-cased-props-deep.d.ts) – Convert object props to kebab-case (`foo-bar`).
+- [`KebabCasedProperties`](ts41/kebab-cased-properties.d.ts) – Convert a object properties to kebab-case recursively (`foo-bar`).
+- [`KebabCasedPropertiesDeep`](ts41/kebab-cased-properties-deep.d.ts) – Convert object properties to kebab-case (`foo-bar`).
 
 - [`PascalCase`](ts41/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
-- [`PascalCasedProperties`](ts41/pascal-cased-props.d.ts) – Converts object props to pascal-case (`FooBar`)
-- [`PascalCasedPropertiesDeep`](ts41/pascal-cased-props-deep.d.ts) – Converts object props to pascal-case (`FooBar`)
+- [`PascalCasedProperties`](ts41/pascal-cased-properties.d.ts) – Converts object properties to pascal-case (`FooBar`)
+- [`PascalCasedPropertiesDeep`](ts41/pascal-cased-properties-deep.d.ts) – Converts object properties to pascal-case (`FooBar`)
 
 - [`SnakeCase`](ts41/snake-case.d.ts) – Convert a string literal to snake-case (`foo_bar`).
-- [`SnakeCasedProperties`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case (`foo_bar`).
-- [`SnakeCasedPropertiesDeep`](ts41/snake-cased-props-deep.d.ts) – Convert object props to snake-case recursively (`foo_bar`).
+- [`SnakeCasedProperties`](ts41/snake-cased-properties-deep.d.ts) – Convert object properties to snake-case (`foo_bar`).
+- [`SnakeCasedPropertiesDeep`](ts41/snake-cased-properties-deep.d.ts) – Convert object properties to snake-case recursively (`foo_bar`).
 
 - [`DelimiterCase`](ts41/delimiter-case.d.ts) – Convert a string literal to a custom string delimiter casing.
-- [`DelimiterCasedProperties`](ts41/delimiter-cased-props.d.ts) – Convert object props to a custom string delimiter casing.
-- [`DelimiterCasedPropertiesDeep`](ts41/delimiter-cased-props-deep.d.ts) – Convert object props to a custom string delimiter casing recursively.
+- [`DelimiterCasedProperties`](ts41/delimiter-cased-properties.d.ts) – Convert object properties to a custom string delimiter casing.
+- [`DelimiterCasedPropertiesDeep`](ts41/delimiter-cased-properties-deep.d.ts) – Convert object properties to a custom string delimiter casing recursively.
 
 - [`Get`](ts41/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 
diff --git a/test-d/camel-cased-props-deep.ts b/test-d/camel-cased-properties-deep.ts
similarity index 98%
rename from test-d/camel-cased-props-deep.ts
rename to test-d/camel-cased-properties-deep.ts
index a2df02775..8812171eb 100644
--- a/test-d/camel-cased-props-deep.ts
+++ b/test-d/camel-cased-properties-deep.ts
@@ -1,4 +1,4 @@
-import {CamelCasedPropertiesDeep} from '../ts41/camel-cased-props-deep';
+import {CamelCasedPropertiesDeep} from '../ts41/camel-cased-properties-deep';
 import {expectType} from 'tsd';
 
 declare const foo: CamelCasedPropertiesDeep<{
diff --git a/test-d/camel-cased-props.ts b/test-d/camel-cased-properties.ts
similarity index 89%
rename from test-d/camel-cased-props.ts
rename to test-d/camel-cased-properties.ts
index 3a4f41af9..eb10f422a 100644
--- a/test-d/camel-cased-props.ts
+++ b/test-d/camel-cased-properties.ts
@@ -1,4 +1,4 @@
-import {CamelCasedProperties} from '../ts41/camel-cased-props';
+import {CamelCasedProperties} from '../ts41/camel-cased-properties';
 import {expectType} from 'tsd';
 
 declare const foo: CamelCasedProperties<{
diff --git a/test-d/delimiter-cased-props-deep.ts b/test-d/delimiter-cased-properties-deep.ts
similarity index 97%
rename from test-d/delimiter-cased-props-deep.ts
rename to test-d/delimiter-cased-properties-deep.ts
index 0bac2d55a..4074bbee5 100644
--- a/test-d/delimiter-cased-props-deep.ts
+++ b/test-d/delimiter-cased-properties-deep.ts
@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import {DelimiterCasedPropertiesDeep} from '../ts41/delimiter-cased-props-deep';
+import {DelimiterCasedPropertiesDeep} from '../ts41/delimiter-cased-properties-deep';
 
 declare const foo: DelimiterCasedPropertiesDeep<{helloWorld: {fooBar: string}}, '/'>;
 expectType<{'hello/world': {'foo/bar': string}}>(foo);
diff --git a/test-d/delimiter-cased-props.ts b/test-d/delimiter-cased-properties.ts
similarity index 98%
rename from test-d/delimiter-cased-props.ts
rename to test-d/delimiter-cased-properties.ts
index 7657c7c98..2b453b85d 100644
--- a/test-d/delimiter-cased-props.ts
+++ b/test-d/delimiter-cased-properties.ts
@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import {DelimiterCasedProperties} from '../ts41/delimiter-cased-props';
+import {DelimiterCasedProperties} from '../ts41/delimiter-cased-properties';
 
 declare const foo: DelimiterCasedProperties<{ helloWorld: { fooBar: string } }, '/'>;
 expectType<{ 'hello/world': { fooBar: string } }>(foo);
diff --git a/test-d/kebab-cased-props-deep.ts b/test-d/kebab-cased-properties-deep.ts
similarity index 97%
rename from test-d/kebab-cased-props-deep.ts
rename to test-d/kebab-cased-properties-deep.ts
index 243b71391..0ccde3dc9 100644
--- a/test-d/kebab-cased-props-deep.ts
+++ b/test-d/kebab-cased-properties-deep.ts
@@ -1,4 +1,4 @@
-import {KebabCasedPropertiesDeep} from '../ts41/kebab-cased-props-deep';
+import {KebabCasedPropertiesDeep} from '../ts41/kebab-cased-properties-deep';
 import {expectType} from 'tsd';
 
 declare const foo: KebabCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
diff --git a/test-d/kebab-cased-props.ts b/test-d/kebab-cased-properties.ts
similarity index 84%
rename from test-d/kebab-cased-props.ts
rename to test-d/kebab-cased-properties.ts
index a8972b2ef..45993618e 100644
--- a/test-d/kebab-cased-props.ts
+++ b/test-d/kebab-cased-properties.ts
@@ -1,4 +1,4 @@
-import {KebabCasedProperties} from '../ts41/kebab-cased-props';
+import {KebabCasedProperties} from '../ts41/kebab-cased-properties';
 import {expectType} from 'tsd';
 
 declare const foo: KebabCasedProperties<{ helloWorld: { fooBar: string } }>;
diff --git a/test-d/pascal-cased-props-deep.ts b/test-d/pascal-cased-properties-deep.ts
similarity index 97%
rename from test-d/pascal-cased-props-deep.ts
rename to test-d/pascal-cased-properties-deep.ts
index 92bb6668b..dd05113d1 100644
--- a/test-d/pascal-cased-props-deep.ts
+++ b/test-d/pascal-cased-properties-deep.ts
@@ -1,4 +1,4 @@
-import {PascalCasedPropertiesDeep} from '../ts41/pascal-cased-props-deep';
+import {PascalCasedPropertiesDeep} from '../ts41/pascal-cased-properties-deep';
 import {expectType} from 'tsd';
 
 declare const foo: PascalCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
diff --git a/test-d/pascal-cased-props.ts b/test-d/pascal-cased-properties.ts
similarity index 89%
rename from test-d/pascal-cased-props.ts
rename to test-d/pascal-cased-properties.ts
index d4f980fb2..ed521ddf5 100644
--- a/test-d/pascal-cased-props.ts
+++ b/test-d/pascal-cased-properties.ts
@@ -1,4 +1,4 @@
-import {PascalCasedProperties} from '../ts41/pascal-cased-props';
+import {PascalCasedProperties} from '../ts41/pascal-cased-properties';
 import {expectType} from 'tsd';
 
 declare const foo: PascalCasedProperties<{ helloWorld: { fooBar: string } }>;
diff --git a/test-d/snake-cased-props-deep.ts b/test-d/snake-cased-properties-deep.ts
similarity index 97%
rename from test-d/snake-cased-props-deep.ts
rename to test-d/snake-cased-properties-deep.ts
index 6734cbee8..3c17a9299 100644
--- a/test-d/snake-cased-props-deep.ts
+++ b/test-d/snake-cased-properties-deep.ts
@@ -1,4 +1,4 @@
-import {SnakeCasedPropertiesDeep} from '../ts41/snake-cased-props-deep';
+import {SnakeCasedPropertiesDeep} from '../ts41/snake-cased-properties-deep';
 import {expectType} from 'tsd';
 
 declare const foo: SnakeCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
diff --git a/test-d/snake-cased-props.ts b/test-d/snake-cased-properties.ts
similarity index 84%
rename from test-d/snake-cased-props.ts
rename to test-d/snake-cased-properties.ts
index 5cb7e2c0f..422deedd8 100644
--- a/test-d/snake-cased-props.ts
+++ b/test-d/snake-cased-properties.ts
@@ -1,4 +1,4 @@
-import {SnakeCasedProperties} from '../ts41/snake-cased-props';
+import {SnakeCasedProperties} from '../ts41/snake-cased-properties';
 import {expectType} from 'tsd';
 
 declare const foo: SnakeCasedProperties<{ helloWorld: { fooBar: string } }>;
diff --git a/ts41/camel-cased-props-deep.d.ts b/ts41/camel-cased-properties-deep.d.ts
similarity index 100%
rename from ts41/camel-cased-props-deep.d.ts
rename to ts41/camel-cased-properties-deep.d.ts
diff --git a/ts41/camel-cased-props.d.ts b/ts41/camel-cased-properties.d.ts
similarity index 100%
rename from ts41/camel-cased-props.d.ts
rename to ts41/camel-cased-properties.d.ts
diff --git a/ts41/delimiter-cased-props-deep.d.ts b/ts41/delimiter-cased-properties-deep.d.ts
similarity index 100%
rename from ts41/delimiter-cased-props-deep.d.ts
rename to ts41/delimiter-cased-properties-deep.d.ts
diff --git a/ts41/delimiter-cased-props.d.ts b/ts41/delimiter-cased-properties.d.ts
similarity index 100%
rename from ts41/delimiter-cased-props.d.ts
rename to ts41/delimiter-cased-properties.d.ts
diff --git a/ts41/kebab-cased-props-deep.d.ts b/ts41/kebab-cased-properties-deep.d.ts
similarity index 97%
rename from ts41/kebab-cased-props-deep.d.ts
rename to ts41/kebab-cased-properties-deep.d.ts
index 52d5e690c..2b5a21f5f 100644
--- a/ts41/kebab-cased-props-deep.d.ts
+++ b/ts41/kebab-cased-properties-deep.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedPropertiesDeep} from './delimiter-cased-props-deep';
+import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 
 /**
 Convert object props to kebab-case recursively.
diff --git a/ts41/kebab-cased-props.d.ts b/ts41/kebab-cased-properties.d.ts
similarity index 85%
rename from ts41/kebab-cased-props.d.ts
rename to ts41/kebab-cased-properties.d.ts
index 5ce507775..ea4b10472 100644
--- a/ts41/kebab-cased-props.d.ts
+++ b/ts41/kebab-cased-properties.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedProperties} from './delimiter-cased-props';
+import {DelimiterCasedProperties} from './delimiter-cased-properties';
 
 /**
 Convert object props to kebab-case but not recursively.
diff --git a/ts41/pascal-cased-props-deep.d.ts b/ts41/pascal-cased-properties-deep.d.ts
similarity index 100%
rename from ts41/pascal-cased-props-deep.d.ts
rename to ts41/pascal-cased-properties-deep.d.ts
diff --git a/ts41/pascal-cased-props.d.ts b/ts41/pascal-cased-properties.d.ts
similarity index 100%
rename from ts41/pascal-cased-props.d.ts
rename to ts41/pascal-cased-properties.d.ts
diff --git a/ts41/snake-cased-props-deep.d.ts b/ts41/snake-cased-properties-deep.d.ts
similarity index 97%
rename from ts41/snake-cased-props-deep.d.ts
rename to ts41/snake-cased-properties-deep.d.ts
index 5f21f5447..d8039b761 100644
--- a/ts41/snake-cased-props-deep.d.ts
+++ b/ts41/snake-cased-properties-deep.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedPropertiesDeep} from './delimiter-cased-props-deep';
+import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 
 /**
 Convert object props to snake_case recursively.
diff --git a/ts41/snake-cased-props.d.ts b/ts41/snake-cased-properties.d.ts
similarity index 85%
rename from ts41/snake-cased-props.d.ts
rename to ts41/snake-cased-properties.d.ts
index 6f1343a16..74cd38511 100644
--- a/ts41/snake-cased-props.d.ts
+++ b/ts41/snake-cased-properties.d.ts
@@ -1,4 +1,4 @@
-import {DelimiterCasedProperties} from './delimiter-cased-props';
+import {DelimiterCasedProperties} from './delimiter-cased-properties';
 
 /**
 Convert object props to snake_case but not recursively.

From a2be1fd63aba6a7c3a05d43ea4b8be68621afd13 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Wed, 10 Mar 2021 16:34:32 +0700
Subject: [PATCH 12/41] Update readme.md

---
 readme.md | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/readme.md b/readme.md
index 0366741dd..435c45f21 100644
--- a/readme.md
+++ b/readme.md
@@ -112,26 +112,20 @@ Click the type names for complete docs.
 - [`CamelCase`](ts41/camel-case.d.ts) – Convert a string literal to camel-case (`fooBar`).
 - [`CamelCasedProperties`](ts41/camel-cased-properties.d.ts) – Convert object properties to camel-case  (`fooBar`).
 - [`CamelCasedPropertiesDeep`](ts41/camel-cased-properties-deep.d.ts) – Convert object properties to camel-case recursively  (`fooBar`).
-
 - [`KebabCase`](ts41/kebab-case.d.ts) – Convert a string literal to kebab-case (`foo-bar`).
 - [`KebabCasedProperties`](ts41/kebab-cased-properties.d.ts) – Convert a object properties to kebab-case recursively (`foo-bar`).
 - [`KebabCasedPropertiesDeep`](ts41/kebab-cased-properties-deep.d.ts) – Convert object properties to kebab-case (`foo-bar`).
-
 - [`PascalCase`](ts41/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
 - [`PascalCasedProperties`](ts41/pascal-cased-properties.d.ts) – Converts object properties to pascal-case (`FooBar`)
 - [`PascalCasedPropertiesDeep`](ts41/pascal-cased-properties-deep.d.ts) – Converts object properties to pascal-case (`FooBar`)
-
 - [`SnakeCase`](ts41/snake-case.d.ts) – Convert a string literal to snake-case (`foo_bar`).
 - [`SnakeCasedProperties`](ts41/snake-cased-properties-deep.d.ts) – Convert object properties to snake-case (`foo_bar`).
 - [`SnakeCasedPropertiesDeep`](ts41/snake-cased-properties-deep.d.ts) – Convert object properties to snake-case recursively (`foo_bar`).
-
 - [`DelimiterCase`](ts41/delimiter-case.d.ts) – Convert a string literal to a custom string delimiter casing.
 - [`DelimiterCasedProperties`](ts41/delimiter-cased-properties.d.ts) – Convert object properties to a custom string delimiter casing.
 - [`DelimiterCasedPropertiesDeep`](ts41/delimiter-cased-properties-deep.d.ts) – Convert object properties to a custom string delimiter casing recursively.
-
 - [`Get`](ts41/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
 
-
 ### Miscellaneous
 
 - [`PackageJson`](source/package-json.d.ts) - Type for [npm's `package.json` file](https://docs.npmjs.com/creating-a-package-json-file).

From 7feb8bdf7b0d8aec1d77caf575ec7786eff0d3d8 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <wwwzbwcom>
Date: Fri, 12 Mar 2021 13:56:13 +0800
Subject: [PATCH 13/41] fix: fix code style and comment style problems

---
 test-d/camel-cased-properties-deep.ts     | 6 ++----
 test-d/camel-cased-properties.ts          | 9 ++-------
 test-d/delimiter-cased-properties.ts      | 4 ++--
 test-d/kebab-cased-properties.ts          | 4 ++--
 test-d/pascal-cased-properties-deep.ts    | 4 ++--
 test-d/pascal-cased-properties.ts         | 4 ++--
 ts41/camel-cased-properties-deep.d.ts     | 3 +--
 ts41/camel-cased-properties.d.ts          | 3 +--
 ts41/delimiter-cased-properties-deep.d.ts | 3 +--
 ts41/delimiter-cased-properties.d.ts      | 3 ++-
 ts41/kebab-cased-properties-deep.d.ts     | 3 +--
 ts41/kebab-cased-properties.d.ts          | 3 ++-
 ts41/pascal-cased-properties-deep.d.ts    | 4 ++--
 ts41/pascal-cased-properties.d.ts         | 4 ++--
 ts41/snake-cased-properties-deep.d.ts     | 4 ++--
 ts41/snake-cased-properties.d.ts          | 4 ++--
 16 files changed, 28 insertions(+), 37 deletions(-)

diff --git a/test-d/camel-cased-properties-deep.ts b/test-d/camel-cased-properties-deep.ts
index 8812171eb..dfe70fcf5 100644
--- a/test-d/camel-cased-properties-deep.ts
+++ b/test-d/camel-cased-properties-deep.ts
@@ -1,11 +1,9 @@
 import {CamelCasedPropertiesDeep} from '../ts41/camel-cased-properties-deep';
 import {expectType} from 'tsd';
 
-declare const foo: CamelCasedPropertiesDeep<{
-	A: { B: number; C: Array<{ D: string }> };
-}>;
+declare const foo: CamelCasedPropertiesDeep<{A: {B: number; C: Array<{D: string}>};}>;
 
-expectType<{ a: { b: number; c: Array<{ d: string }> } }>(foo);
+expectType<{a: {b: number; c: Array<{d: string}>}}>(foo);
 
 declare const fooBar: CamelCasedPropertiesDeep<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
diff --git a/test-d/camel-cased-properties.ts b/test-d/camel-cased-properties.ts
index eb10f422a..69577bc6c 100644
--- a/test-d/camel-cased-properties.ts
+++ b/test-d/camel-cased-properties.ts
@@ -1,14 +1,9 @@
 import {CamelCasedProperties} from '../ts41/camel-cased-properties';
 import {expectType} from 'tsd';
 
-declare const foo: CamelCasedProperties<{
-	A: number;
-	B: {
-		C: string;
-	};
-}>;
+declare const foo: CamelCasedProperties<{A: number; B: {C: string;};}>;
 
-expectType<{ a: number; b: { C: string } }>(foo);
+expectType<{a: number; b:{C: string}}>(foo);
 
 declare const bar: CamelCasedProperties<Array<{helloWorld: string}>>;
 expectType<Array<{helloWorld: string}>>(bar);
diff --git a/test-d/delimiter-cased-properties.ts b/test-d/delimiter-cased-properties.ts
index 2b453b85d..0c4b8877d 100644
--- a/test-d/delimiter-cased-properties.ts
+++ b/test-d/delimiter-cased-properties.ts
@@ -1,8 +1,8 @@
 import {expectType} from 'tsd';
 import {DelimiterCasedProperties} from '../ts41/delimiter-cased-properties';
 
-declare const foo: DelimiterCasedProperties<{ helloWorld: { fooBar: string } }, '/'>;
-expectType<{ 'hello/world': { fooBar: string } }>(foo);
+declare const foo: DelimiterCasedProperties<{helloWorld: {fooBar: string}}, '/'>;
+expectType<{'hello/world': {fooBar: string}}>(foo);
 
 declare const bar: DelimiterCasedProperties<Array<{helloWorld: string}>, '-'>;
 expectType<Array<{helloWorld: string}>>(bar);
diff --git a/test-d/kebab-cased-properties.ts b/test-d/kebab-cased-properties.ts
index 45993618e..2417a3cb4 100644
--- a/test-d/kebab-cased-properties.ts
+++ b/test-d/kebab-cased-properties.ts
@@ -1,8 +1,8 @@
 import {KebabCasedProperties} from '../ts41/kebab-cased-properties';
 import {expectType} from 'tsd';
 
-declare const foo: KebabCasedProperties<{ helloWorld: { fooBar: string } }>;
-expectType<{ 'hello-world': { fooBar: string } }>(foo);
+declare const foo: KebabCasedProperties<{helloWorld: {fooBar: string}}>;
+expectType<{'hello-world': {fooBar: string}}>(foo);
 
 // Verify Example
 interface User {
diff --git a/test-d/pascal-cased-properties-deep.ts b/test-d/pascal-cased-properties-deep.ts
index dd05113d1..65ba515a0 100644
--- a/test-d/pascal-cased-properties-deep.ts
+++ b/test-d/pascal-cased-properties-deep.ts
@@ -1,8 +1,8 @@
 import {PascalCasedPropertiesDeep} from '../ts41/pascal-cased-properties-deep';
 import {expectType} from 'tsd';
 
-declare const foo: PascalCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
-expectType<{ HelloWorld: { FooBar: string } }>(foo);
+declare const foo: PascalCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
+expectType<{HelloWorld: {FooBar: string}}>(foo);
 
 declare const fooBar: PascalCasedPropertiesDeep<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
diff --git a/test-d/pascal-cased-properties.ts b/test-d/pascal-cased-properties.ts
index ed521ddf5..a869b9d82 100644
--- a/test-d/pascal-cased-properties.ts
+++ b/test-d/pascal-cased-properties.ts
@@ -1,8 +1,8 @@
 import {PascalCasedProperties} from '../ts41/pascal-cased-properties';
 import {expectType} from 'tsd';
 
-declare const foo: PascalCasedProperties<{ helloWorld: { fooBar: string } }>;
-expectType<{ HelloWorld: { fooBar: string } }>(foo);
+declare const foo: PascalCasedProperties<{helloWorld: {fooBar: string}}>;
+expectType<{HelloWorld: {fooBar: string}}>(foo);
 
 declare const bar: PascalCasedProperties<Array<{helloWorld: string}>>;
 expectType<Array<{helloWorld: string}>>(bar);
diff --git a/ts41/camel-cased-properties-deep.d.ts b/ts41/camel-cased-properties-deep.d.ts
index af3f874f6..e91d0c8e3 100644
--- a/ts41/camel-cased-properties-deep.d.ts
+++ b/ts41/camel-cased-properties-deep.d.ts
@@ -1,7 +1,7 @@
 import {CamelCase} from './camel-case';
 
 /**
-Convert object props to camelCase recursively.
+Convert object properties to camel case recursively.
 
 This can be useful when, for example, converting some API types from other style.
 
@@ -35,7 +35,6 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
-
 ```
 */
 export type CamelCasedPropertiesDeep<Value> = Value extends Function
diff --git a/ts41/camel-cased-properties.d.ts b/ts41/camel-cased-properties.d.ts
index 89f8e131a..f2ebad8b2 100644
--- a/ts41/camel-cased-properties.d.ts
+++ b/ts41/camel-cased-properties.d.ts
@@ -1,7 +1,7 @@
 import {CamelCase} from './camel-case';
 
 /**
-Convert object props to camelCase but not recursively.
+Convert object properties to camel case but not recursively.
 
 This can be useful when, for example, converting some api type from other style.
 
@@ -18,7 +18,6 @@ const result: CamelCasedProperties<User> = {
 	userId: 1,
 	userName: 'Tom',
 };
-
 ```
 */
 export type CamelCasedProperties<Value> = Value extends Function
diff --git a/ts41/delimiter-cased-properties-deep.d.ts b/ts41/delimiter-cased-properties-deep.d.ts
index 4f3c1a43b..37aa80d32 100644
--- a/ts41/delimiter-cased-properties-deep.d.ts
+++ b/ts41/delimiter-cased-properties-deep.d.ts
@@ -1,7 +1,7 @@
 import {DelimiterCase} from './delimiter-case';
 
 /**
-Convert object props to delimiter-case recursively.
+Convert object properties to delimiter case recursively.
 
 This can be useful when, for example, converting some API types from other style.
 
@@ -35,7 +35,6 @@ const result: DelimiterCasedPropertiesDeep<UserWithFriends, '-'> = {
 		},
 	],
 };
-
 ```
 */
 export type DelimiterCasedPropertiesDeep<
diff --git a/ts41/delimiter-cased-properties.d.ts b/ts41/delimiter-cased-properties.d.ts
index c2529c966..09b04aa37 100644
--- a/ts41/delimiter-cased-properties.d.ts
+++ b/ts41/delimiter-cased-properties.d.ts
@@ -1,7 +1,7 @@
 import {DelimiterCase} from './delimiter-case';
 
 /**
-Convert object props to delimiter-case but not recursively.
+Convert object properties to delimiter case but not recursively.
 
 This can be useful when, for example, converting some api type from other style.
 
@@ -13,6 +13,7 @@ interface User {
 	userId: number;
 	userName: string;
 }
+
 const result: DelimiterCasedProperties<User, '-'> = {
 	'user-id': 1,
 	'user-name': 'Tom',
diff --git a/ts41/kebab-cased-properties-deep.d.ts b/ts41/kebab-cased-properties-deep.d.ts
index 2b5a21f5f..f9a4097ce 100644
--- a/ts41/kebab-cased-properties-deep.d.ts
+++ b/ts41/kebab-cased-properties-deep.d.ts
@@ -1,7 +1,7 @@
 import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 
 /**
-Convert object props to kebab-case recursively.
+Convert object properties to kebab case recursively.
 
 This can be useful when, for example, converting some API types from other style.
 
@@ -35,7 +35,6 @@ const result: KebabCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
-
 ```
 */
 export type KebabCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '-'>;
diff --git a/ts41/kebab-cased-properties.d.ts b/ts41/kebab-cased-properties.d.ts
index ea4b10472..e492d70a0 100644
--- a/ts41/kebab-cased-properties.d.ts
+++ b/ts41/kebab-cased-properties.d.ts
@@ -1,7 +1,7 @@
 import {DelimiterCasedProperties} from './delimiter-cased-properties';
 
 /**
-Convert object props to kebab-case but not recursively.
+Convert object properties to kebab case but not recursively.
 
 This can be useful when, for example, converting some api type from other style.
 
@@ -13,6 +13,7 @@ interface User {
 	userId: number;
 	userName: string;
 }
+
 const result: KebabCasedProperties<User> = {
 	'user-id': 1,
 	'user-name': 'Tom',
diff --git a/ts41/pascal-cased-properties-deep.d.ts b/ts41/pascal-cased-properties-deep.d.ts
index 509e478cd..c1046e328 100644
--- a/ts41/pascal-cased-properties-deep.d.ts
+++ b/ts41/pascal-cased-properties-deep.d.ts
@@ -1,7 +1,7 @@
 import {PascalCase} from './pascal-case';
 
 /**
-Convert object props to PascalCase recursively.
+Convert object properties to pascal case recursively.
 
 This can be useful when, for example, converting some API types from other style.
 
@@ -35,7 +35,7 @@ const result: PascalCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
-
+```
 */
 export type PascalCasedPropertiesDeep<Value> = Value extends Function
 	? Value
diff --git a/ts41/pascal-cased-properties.d.ts b/ts41/pascal-cased-properties.d.ts
index a0fa79e3d..f04e30841 100644
--- a/ts41/pascal-cased-properties.d.ts
+++ b/ts41/pascal-cased-properties.d.ts
@@ -1,7 +1,7 @@
 import {PascalCase} from './pascal-case';
 
 /**
-Convert object props to PascalCase but not recursively.
+Convert object properties to pascal case but not recursively.
 
 This can be useful when, for example, converting some api type from other style.
 
@@ -13,11 +13,11 @@ interface User {
 	userId: number;
 	userName: string;
 }
+
 const result: PascalCasedProperties<User> = {
 	UserId: 1,
 	UserName: 'Tom',
 };
-
 ```
 */
 export type PascalCasedProperties<Value> = Value extends Function
diff --git a/ts41/snake-cased-properties-deep.d.ts b/ts41/snake-cased-properties-deep.d.ts
index d8039b761..6203b3d75 100644
--- a/ts41/snake-cased-properties-deep.d.ts
+++ b/ts41/snake-cased-properties-deep.d.ts
@@ -1,7 +1,7 @@
 import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 
 /**
-Convert object props to snake_case recursively.
+Convert object properties to snake case recursively.
 
 This can be useful when, for example, converting some API types from other style.
 
@@ -35,6 +35,6 @@ const result: SnakeCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
-
+```
 */
 export type SnakeCasedPropertiesDeep<Value> = DelimiterCasedPropertiesDeep<Value, '_'>;
diff --git a/ts41/snake-cased-properties.d.ts b/ts41/snake-cased-properties.d.ts
index 74cd38511..7e9709a4f 100644
--- a/ts41/snake-cased-properties.d.ts
+++ b/ts41/snake-cased-properties.d.ts
@@ -1,7 +1,7 @@
 import {DelimiterCasedProperties} from './delimiter-cased-properties';
 
 /**
-Convert object props to snake_case but not recursively.
+Convert object properties to snake case but not recursively.
 
 This can be useful when, for example, converting some api type from other style.
 
@@ -13,11 +13,11 @@ interface User {
 	userId: number;
 	userName: string;
 }
+
 const result: SnakeCasedProperties<User> = {
 	user_id: 1,
 	user_name: 'Tom',
 };
-
 ```
 */
 export type SnakeCasedProperties<Value> = DelimiterCasedProperties<Value, '_'>;

From 12e79f195f6bf3d588429f7b876adb65434bb963 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <wwwzbwcom>
Date: Fri, 12 Mar 2021 14:06:02 +0800
Subject: [PATCH 14/41] fix: add checking with set

---
 test-d/camel-cased-properties-deep.ts     | 3 +++
 test-d/delimiter-cased-properties-deep.ts | 3 +++
 test-d/kebab-cased-properties-deep.ts     | 3 +++
 test-d/pascal-cased-properties-deep.ts    | 3 +++
 test-d/snake-cased-properties-deep.ts     | 7 +++++--
 test-d/snake-cased-properties.ts          | 4 ++--
 ts41/camel-cased-properties-deep.d.ts     | 3 ++-
 ts41/delimiter-cased-properties-deep.d.ts | 3 ++-
 ts41/pascal-cased-properties-deep.d.ts    | 3 ++-
 9 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/test-d/camel-cased-properties-deep.ts b/test-d/camel-cased-properties-deep.ts
index dfe70fcf5..42432b7b2 100644
--- a/test-d/camel-cased-properties-deep.ts
+++ b/test-d/camel-cased-properties-deep.ts
@@ -8,6 +8,9 @@ expectType<{a: {b: number; c: Array<{d: string}>}}>(foo);
 declare const fooBar: CamelCasedPropertiesDeep<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
+declare const bar : CamelCasedPropertiesDeep<Set<{fooBar: string}>>
+expectType<Set<{fooBar:string}>>(bar);
+
 // Verify Example
 interface User {
 	UserId: number;
diff --git a/test-d/delimiter-cased-properties-deep.ts b/test-d/delimiter-cased-properties-deep.ts
index 4074bbee5..ccef4e3d6 100644
--- a/test-d/delimiter-cased-properties-deep.ts
+++ b/test-d/delimiter-cased-properties-deep.ts
@@ -7,6 +7,9 @@ expectType<{'hello/world': {'foo/bar': string}}>(foo);
 declare const fooBar: DelimiterCasedPropertiesDeep<() => {a: string}, '/'>;
 expectType<() => {a: string}>(fooBar);
 
+declare const bar : DelimiterCasedPropertiesDeep<Set<{fooBar: string}>, '-'>;
+expectType<Set<{'foo-bar'}>>(bar);
+
 // Verify Example
 interface User {
 	userId: number;
diff --git a/test-d/kebab-cased-properties-deep.ts b/test-d/kebab-cased-properties-deep.ts
index 0ccde3dc9..7cc1d0b66 100644
--- a/test-d/kebab-cased-properties-deep.ts
+++ b/test-d/kebab-cased-properties-deep.ts
@@ -4,6 +4,9 @@ import {expectType} from 'tsd';
 declare const foo: KebabCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
 expectType<{'hello-world': {'foo-bar': string}}>(foo);
 
+declare const bar : KebabCasedPropertiesDeep<Set<{fooBar: string}>>
+expectType<Set<{'foo-bar':string}>>(bar);
+
 // Verify Example
 interface User {
 	userId: number;
diff --git a/test-d/pascal-cased-properties-deep.ts b/test-d/pascal-cased-properties-deep.ts
index 65ba515a0..f0e1acc70 100644
--- a/test-d/pascal-cased-properties-deep.ts
+++ b/test-d/pascal-cased-properties-deep.ts
@@ -7,6 +7,9 @@ expectType<{HelloWorld: {FooBar: string}}>(foo);
 declare const fooBar: PascalCasedPropertiesDeep<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
+declare const bar : PascalCasedPropertiesDeep<Set<{fooBar: string}>>
+expectType<Set<{FooBar:string}>>(bar);
+
 // Verify Example
 interface User {
 	userId: number;
diff --git a/test-d/snake-cased-properties-deep.ts b/test-d/snake-cased-properties-deep.ts
index 3c17a9299..c60fafde2 100644
--- a/test-d/snake-cased-properties-deep.ts
+++ b/test-d/snake-cased-properties-deep.ts
@@ -1,8 +1,11 @@
 import {SnakeCasedPropertiesDeep} from '../ts41/snake-cased-properties-deep';
 import {expectType} from 'tsd';
 
-declare const foo: SnakeCasedPropertiesDeep<{ helloWorld: { fooBar: string } }>;
-expectType<{ hello_world: { foo_bar: string } }>(foo);
+declare const foo: SnakeCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
+expectType<{hello_world: {foo_bar: string}}>(foo);
+
+declare const bar : SnakeCasedPropertiesDeep<Set<{fooBar: string}>>
+expectType<Set<{foo_bar:string}>>(bar);
 
 // Verify Example
 interface User {
diff --git a/test-d/snake-cased-properties.ts b/test-d/snake-cased-properties.ts
index 422deedd8..2a7b9cead 100644
--- a/test-d/snake-cased-properties.ts
+++ b/test-d/snake-cased-properties.ts
@@ -1,8 +1,8 @@
 import {SnakeCasedProperties} from '../ts41/snake-cased-properties';
 import {expectType} from 'tsd';
 
-declare const foo: SnakeCasedProperties<{ helloWorld: { fooBar: string } }>;
-expectType<{ hello_world: { fooBar: string } }>(foo);
+declare const foo: SnakeCasedProperties<{helloWorld: {fooBar: string}}>;
+expectType<{hello_world: {fooBar: string}}>(foo);
 
 // Verify Example
 interface User {
diff --git a/ts41/camel-cased-properties-deep.d.ts b/ts41/camel-cased-properties-deep.d.ts
index e91d0c8e3..fc6d3c283 100644
--- a/ts41/camel-cased-properties-deep.d.ts
+++ b/ts41/camel-cased-properties-deep.d.ts
@@ -41,6 +41,7 @@ export type CamelCasedPropertiesDeep<Value> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 	? Array<CamelCasedPropertiesDeep<U>>
-	: {
+	: Value extends Set<infer U>
+	? Set<CamelCasedPropertiesDeep<U>> : {
 			[K in keyof Value as CamelCase<K>]: CamelCasedPropertiesDeep<Value[K]>;
 	};
diff --git a/ts41/delimiter-cased-properties-deep.d.ts b/ts41/delimiter-cased-properties-deep.d.ts
index 37aa80d32..3cbba74d1 100644
--- a/ts41/delimiter-cased-properties-deep.d.ts
+++ b/ts41/delimiter-cased-properties-deep.d.ts
@@ -44,7 +44,8 @@ export type DelimiterCasedPropertiesDeep<
 	? Value
 	: Value extends Array<infer U>
 	? Array<DelimiterCasedPropertiesDeep<U, Delimiter>>
-	: {
+	: Value extends Set<infer U>
+	? Set<DelimiterCasedPropertiesDeep<U, Delimiter>> : {
 			[K in keyof Value as DelimiterCase<
 				K,
 				Delimiter
diff --git a/ts41/pascal-cased-properties-deep.d.ts b/ts41/pascal-cased-properties-deep.d.ts
index c1046e328..211f937d8 100644
--- a/ts41/pascal-cased-properties-deep.d.ts
+++ b/ts41/pascal-cased-properties-deep.d.ts
@@ -41,6 +41,7 @@ export type PascalCasedPropertiesDeep<Value> = Value extends Function
 	? Value
 	: Value extends Array<infer U>
 	? Array<PascalCasedPropertiesDeep<U>>
-	: {
+	: Value extends Set<infer U>
+	? Set<PascalCasedPropertiesDeep<U>> : {
 			[K in keyof Value as PascalCase<K>]: PascalCasedPropertiesDeep<Value[K]>;
 	};

From cc2ad40f99b0f3fec515a43d48c63773964804b8 Mon Sep 17 00:00:00 2001
From: wwwzbwcom <wwwzbwcom>
Date: Fri, 12 Mar 2021 14:36:45 +0800
Subject: [PATCH 15/41] fix: fix lint issues

---
 test-d/camel-cased-properties-deep.ts     | 6 +++---
 test-d/camel-cased-properties.ts          | 4 ++--
 test-d/delimiter-cased-properties-deep.ts | 4 ++--
 test-d/kebab-cased-properties-deep.ts     | 4 ++--
 test-d/pascal-cased-properties-deep.ts    | 4 ++--
 test-d/snake-cased-properties-deep.ts     | 4 ++--
 6 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/test-d/camel-cased-properties-deep.ts b/test-d/camel-cased-properties-deep.ts
index 42432b7b2..c58ed2ffc 100644
--- a/test-d/camel-cased-properties-deep.ts
+++ b/test-d/camel-cased-properties-deep.ts
@@ -1,15 +1,15 @@
 import {CamelCasedPropertiesDeep} from '../ts41/camel-cased-properties-deep';
 import {expectType} from 'tsd';
 
-declare const foo: CamelCasedPropertiesDeep<{A: {B: number; C: Array<{D: string}>};}>;
+declare const foo: CamelCasedPropertiesDeep<{A: {B: number; C: Array<{D: string}>}}>;
 
 expectType<{a: {b: number; c: Array<{d: string}>}}>(foo);
 
 declare const fooBar: CamelCasedPropertiesDeep<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
-declare const bar : CamelCasedPropertiesDeep<Set<{fooBar: string}>>
-expectType<Set<{fooBar:string}>>(bar);
+declare const bar: CamelCasedPropertiesDeep<Set<{fooBar: string}>>;
+expectType<Set<{fooBar: string}>>(bar);
 
 // Verify Example
 interface User {
diff --git a/test-d/camel-cased-properties.ts b/test-d/camel-cased-properties.ts
index 69577bc6c..d41a3f75d 100644
--- a/test-d/camel-cased-properties.ts
+++ b/test-d/camel-cased-properties.ts
@@ -1,9 +1,9 @@
 import {CamelCasedProperties} from '../ts41/camel-cased-properties';
 import {expectType} from 'tsd';
 
-declare const foo: CamelCasedProperties<{A: number; B: {C: string;};}>;
+declare const foo: CamelCasedProperties<{A: number; B: {C: string}}>;
 
-expectType<{a: number; b:{C: string}}>(foo);
+expectType<{a: number; b: {C: string}}>(foo);
 
 declare const bar: CamelCasedProperties<Array<{helloWorld: string}>>;
 expectType<Array<{helloWorld: string}>>(bar);
diff --git a/test-d/delimiter-cased-properties-deep.ts b/test-d/delimiter-cased-properties-deep.ts
index ccef4e3d6..133b42ef1 100644
--- a/test-d/delimiter-cased-properties-deep.ts
+++ b/test-d/delimiter-cased-properties-deep.ts
@@ -7,8 +7,8 @@ expectType<{'hello/world': {'foo/bar': string}}>(foo);
 declare const fooBar: DelimiterCasedPropertiesDeep<() => {a: string}, '/'>;
 expectType<() => {a: string}>(fooBar);
 
-declare const bar : DelimiterCasedPropertiesDeep<Set<{fooBar: string}>, '-'>;
-expectType<Set<{'foo-bar'}>>(bar);
+declare const bar: DelimiterCasedPropertiesDeep<Set<{fooBar: string}>, '-'>;
+expectType<Set<{'foo-bar': string}>>(bar);
 
 // Verify Example
 interface User {
diff --git a/test-d/kebab-cased-properties-deep.ts b/test-d/kebab-cased-properties-deep.ts
index 7cc1d0b66..b1eec24aa 100644
--- a/test-d/kebab-cased-properties-deep.ts
+++ b/test-d/kebab-cased-properties-deep.ts
@@ -4,8 +4,8 @@ import {expectType} from 'tsd';
 declare const foo: KebabCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
 expectType<{'hello-world': {'foo-bar': string}}>(foo);
 
-declare const bar : KebabCasedPropertiesDeep<Set<{fooBar: string}>>
-expectType<Set<{'foo-bar':string}>>(bar);
+declare const bar: KebabCasedPropertiesDeep<Set<{fooBar: string}>>;
+expectType<Set<{'foo-bar': string}>>(bar);
 
 // Verify Example
 interface User {
diff --git a/test-d/pascal-cased-properties-deep.ts b/test-d/pascal-cased-properties-deep.ts
index f0e1acc70..6812e96e3 100644
--- a/test-d/pascal-cased-properties-deep.ts
+++ b/test-d/pascal-cased-properties-deep.ts
@@ -7,8 +7,8 @@ expectType<{HelloWorld: {FooBar: string}}>(foo);
 declare const fooBar: PascalCasedPropertiesDeep<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
-declare const bar : PascalCasedPropertiesDeep<Set<{fooBar: string}>>
-expectType<Set<{FooBar:string}>>(bar);
+declare const bar: PascalCasedPropertiesDeep<Set<{fooBar: string}>>;
+expectType<Set<{FooBar: string}>>(bar);
 
 // Verify Example
 interface User {
diff --git a/test-d/snake-cased-properties-deep.ts b/test-d/snake-cased-properties-deep.ts
index c60fafde2..3fab55778 100644
--- a/test-d/snake-cased-properties-deep.ts
+++ b/test-d/snake-cased-properties-deep.ts
@@ -4,8 +4,8 @@ import {expectType} from 'tsd';
 declare const foo: SnakeCasedPropertiesDeep<{helloWorld: {fooBar: string}}>;
 expectType<{hello_world: {foo_bar: string}}>(foo);
 
-declare const bar : SnakeCasedPropertiesDeep<Set<{fooBar: string}>>
-expectType<Set<{foo_bar:string}>>(bar);
+declare const bar: SnakeCasedPropertiesDeep<Set<{fooBar: string}>>;
+expectType<Set<{foo_bar: string}>>(bar);
 
 // Verify Example
 interface User {

From 2761c53e5dfab9b94e001df2fe832d2745383cf1 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:25 +0700
Subject: [PATCH 16/41] Update camel-cased-properties-deep.ts

---
 test-d/camel-cased-properties-deep.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/camel-cased-properties-deep.ts b/test-d/camel-cased-properties-deep.ts
index c58ed2ffc..23a9bd8cc 100644
--- a/test-d/camel-cased-properties-deep.ts
+++ b/test-d/camel-cased-properties-deep.ts
@@ -11,7 +11,7 @@ expectType<() => {a: string}>(fooBar);
 declare const bar: CamelCasedPropertiesDeep<Set<{fooBar: string}>>;
 expectType<Set<{fooBar: string}>>(bar);
 
-// Verify Example
+// Verify example
 interface User {
 	UserId: number;
 	UserName: string;

From 78ed37d043f8a6899ffbd9c1f2a4c400e683ab9d Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:29 +0700
Subject: [PATCH 17/41] Update camel-cased-properties.ts

---
 test-d/camel-cased-properties.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/camel-cased-properties.ts b/test-d/camel-cased-properties.ts
index d41a3f75d..0263ca7c3 100644
--- a/test-d/camel-cased-properties.ts
+++ b/test-d/camel-cased-properties.ts
@@ -11,7 +11,7 @@ expectType<Array<{helloWorld: string}>>(bar);
 declare const fooBar: CamelCasedProperties<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
-// Verify Example
+// Verify example
 interface User {
 	UserId: number;
 	UserName: string;

From a2dcc452acca63fa3a285fe02252092fb6e92bae Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:34 +0700
Subject: [PATCH 18/41] Update delimiter-cased-properties-deep.ts

---
 test-d/delimiter-cased-properties-deep.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/delimiter-cased-properties-deep.ts b/test-d/delimiter-cased-properties-deep.ts
index 133b42ef1..1e34ffeb4 100644
--- a/test-d/delimiter-cased-properties-deep.ts
+++ b/test-d/delimiter-cased-properties-deep.ts
@@ -10,7 +10,7 @@ expectType<() => {a: string}>(fooBar);
 declare const bar: DelimiterCasedPropertiesDeep<Set<{fooBar: string}>, '-'>;
 expectType<Set<{'foo-bar': string}>>(bar);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 08e9f7afd1bab40cb6b0bcb1ec3b63d283afe4ee Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:38 +0700
Subject: [PATCH 19/41] Update delimiter-cased-properties.ts

---
 test-d/delimiter-cased-properties.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/delimiter-cased-properties.ts b/test-d/delimiter-cased-properties.ts
index 0c4b8877d..0e4739f84 100644
--- a/test-d/delimiter-cased-properties.ts
+++ b/test-d/delimiter-cased-properties.ts
@@ -10,7 +10,7 @@ expectType<Array<{helloWorld: string}>>(bar);
 declare const fooBar: DelimiterCasedProperties<() => {a: string}, '-'>;
 expectType<() => {a: string}>(fooBar);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 99478cf90598bb9f8661542360dd87676a987bda Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:42 +0700
Subject: [PATCH 20/41] Update kebab-cased-properties-deep.ts

---
 test-d/kebab-cased-properties-deep.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/kebab-cased-properties-deep.ts b/test-d/kebab-cased-properties-deep.ts
index b1eec24aa..23563e286 100644
--- a/test-d/kebab-cased-properties-deep.ts
+++ b/test-d/kebab-cased-properties-deep.ts
@@ -7,7 +7,7 @@ expectType<{'hello-world': {'foo-bar': string}}>(foo);
 declare const bar: KebabCasedPropertiesDeep<Set<{fooBar: string}>>;
 expectType<Set<{'foo-bar': string}>>(bar);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 99c85b07d458289b04c7b249601de837e6dfef95 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:46 +0700
Subject: [PATCH 21/41] Update kebab-cased-properties.ts

---
 test-d/kebab-cased-properties.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/kebab-cased-properties.ts b/test-d/kebab-cased-properties.ts
index 2417a3cb4..9d2d9bf6d 100644
--- a/test-d/kebab-cased-properties.ts
+++ b/test-d/kebab-cased-properties.ts
@@ -4,7 +4,7 @@ import {expectType} from 'tsd';
 declare const foo: KebabCasedProperties<{helloWorld: {fooBar: string}}>;
 expectType<{'hello-world': {fooBar: string}}>(foo);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 6851e87ed5cef767a38310d118cb8ab3a6565521 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:49 +0700
Subject: [PATCH 22/41] Update pascal-cased-properties-deep.ts

---
 test-d/pascal-cased-properties-deep.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/pascal-cased-properties-deep.ts b/test-d/pascal-cased-properties-deep.ts
index 6812e96e3..da192a858 100644
--- a/test-d/pascal-cased-properties-deep.ts
+++ b/test-d/pascal-cased-properties-deep.ts
@@ -10,7 +10,7 @@ expectType<() => {a: string}>(fooBar);
 declare const bar: PascalCasedPropertiesDeep<Set<{fooBar: string}>>;
 expectType<Set<{FooBar: string}>>(bar);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 88f21b1307460bc11c74b0b517cb4b8d4bacf966 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:54 +0700
Subject: [PATCH 23/41] Update pascal-cased-properties.ts

---
 test-d/pascal-cased-properties.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/pascal-cased-properties.ts b/test-d/pascal-cased-properties.ts
index a869b9d82..77851b85a 100644
--- a/test-d/pascal-cased-properties.ts
+++ b/test-d/pascal-cased-properties.ts
@@ -10,7 +10,7 @@ expectType<Array<{helloWorld: string}>>(bar);
 declare const fooBar: PascalCasedProperties<() => {a: string}>;
 expectType<() => {a: string}>(fooBar);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 00597a149312151907a3129523692cd16e01b3c1 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:03:59 +0700
Subject: [PATCH 24/41] Update snake-cased-properties-deep.ts

---
 test-d/snake-cased-properties-deep.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/snake-cased-properties-deep.ts b/test-d/snake-cased-properties-deep.ts
index 3fab55778..0b27e187a 100644
--- a/test-d/snake-cased-properties-deep.ts
+++ b/test-d/snake-cased-properties-deep.ts
@@ -7,7 +7,7 @@ expectType<{hello_world: {foo_bar: string}}>(foo);
 declare const bar: SnakeCasedPropertiesDeep<Set<{fooBar: string}>>;
 expectType<Set<{foo_bar: string}>>(bar);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From 8a8b7c1cacf4b7a5935cc8d4dc2ee6374db19fb3 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:04:03 +0700
Subject: [PATCH 25/41] Update snake-cased-properties.ts

---
 test-d/snake-cased-properties.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test-d/snake-cased-properties.ts b/test-d/snake-cased-properties.ts
index 2a7b9cead..b86d3dbe0 100644
--- a/test-d/snake-cased-properties.ts
+++ b/test-d/snake-cased-properties.ts
@@ -4,7 +4,7 @@ import {expectType} from 'tsd';
 declare const foo: SnakeCasedProperties<{helloWorld: {fooBar: string}}>;
 expectType<{hello_world: {fooBar: string}}>(foo);
 
-// Verify Example
+// Verify example
 interface User {
 	userId: number;
 	userName: string;

From e800ff488b311c60fdf65fbd76690a821fcc3fb6 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:05:56 +0700
Subject: [PATCH 26/41] Update camel-cased-properties-deep.d.ts

---
 ts41/camel-cased-properties-deep.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ts41/camel-cased-properties-deep.d.ts b/ts41/camel-cased-properties-deep.d.ts
index fc6d3c283..0a44661f5 100644
--- a/ts41/camel-cased-properties-deep.d.ts
+++ b/ts41/camel-cased-properties-deep.d.ts
@@ -7,6 +7,7 @@ This can be useful when, for example, converting some API types from other style
 
 @see CamelCasedProperties
 @see CamelCase
+
 @example
 ```
 interface User {

From 63abd7a7cbcc2ad8b73c2574beaef650699cfb74 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:06:03 +0700
Subject: [PATCH 27/41] Update camel-cased-properties.d.ts

---
 ts41/camel-cased-properties.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ts41/camel-cased-properties.d.ts b/ts41/camel-cased-properties.d.ts
index f2ebad8b2..574b74e89 100644
--- a/ts41/camel-cased-properties.d.ts
+++ b/ts41/camel-cased-properties.d.ts
@@ -7,6 +7,7 @@ This can be useful when, for example, converting some api type from other style.
 
 @see CamelCasedPropertiesDeep
 @see CamelCase
+
 @example
 ```
 interface User {

From abb7779a1c1ee6691e89fc5c8cfc76e8b509f450 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:06:09 +0700
Subject: [PATCH 28/41] Update delimiter-cased-properties-deep.d.ts

---
 ts41/delimiter-cased-properties-deep.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ts41/delimiter-cased-properties-deep.d.ts b/ts41/delimiter-cased-properties-deep.d.ts
index 3cbba74d1..cf60a4b79 100644
--- a/ts41/delimiter-cased-properties-deep.d.ts
+++ b/ts41/delimiter-cased-properties-deep.d.ts
@@ -7,6 +7,7 @@ This can be useful when, for example, converting some API types from other style
 
 @see DelimiterCase
 @see DelimiterCasedProperties
+
 @example
 ```
 interface User {

From febcd45f16ad7f901128e4b010189facd0590858 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:06:18 +0700
Subject: [PATCH 29/41] Update delimiter-cased-properties.d.ts

---
 ts41/delimiter-cased-properties.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ts41/delimiter-cased-properties.d.ts b/ts41/delimiter-cased-properties.d.ts
index 09b04aa37..316e404ef 100644
--- a/ts41/delimiter-cased-properties.d.ts
+++ b/ts41/delimiter-cased-properties.d.ts
@@ -7,6 +7,7 @@ This can be useful when, for example, converting some api type from other style.
 
 @see DelimiterCase
 @see DelimiterCasedPropertiesDeep
+
 @example
 ```
 interface User {

From ab47737445313eba7cdfca2bdc79fcc409b91d59 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:06:29 +0700
Subject: [PATCH 30/41] Update kebab-cased-properties-deep.d.ts

---
 ts41/kebab-cased-properties-deep.d.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/ts41/kebab-cased-properties-deep.d.ts b/ts41/kebab-cased-properties-deep.d.ts
index f9a4097ce..91b81692f 100644
--- a/ts41/kebab-cased-properties-deep.d.ts
+++ b/ts41/kebab-cased-properties-deep.d.ts
@@ -7,6 +7,7 @@ This can be useful when, for example, converting some API types from other style
 
 @see KebabCase
 @see KebabCasedProperties
+
 @example
 ```
 interface User {

From 14e8c7dab5ca6591a447801dace359b1786cef40 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:06:54 +0700
Subject: [PATCH 31/41] Update kebab-cased-properties.d.ts

---
 ts41/kebab-cased-properties.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ts41/kebab-cased-properties.d.ts b/ts41/kebab-cased-properties.d.ts
index e492d70a0..fd0f2e26c 100644
--- a/ts41/kebab-cased-properties.d.ts
+++ b/ts41/kebab-cased-properties.d.ts
@@ -3,10 +3,11 @@ import {DelimiterCasedProperties} from './delimiter-cased-properties';
 /**
 Convert object properties to kebab case but not recursively.
 
-This can be useful when, for example, converting some api type from other style.
+This can be useful when, for example, converting some API type from other style.
 
 @see KebabCase
 @see KebabCasedPropertiesDeep
+
 @example
 ```
 interface User {

From afcc81240e7a8742dcea5f02454c8d5d02333785 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:07:27 +0700
Subject: [PATCH 32/41] Update pascal-cased-properties-deep.d.ts

---
 ts41/pascal-cased-properties-deep.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ts41/pascal-cased-properties-deep.d.ts b/ts41/pascal-cased-properties-deep.d.ts
index 211f937d8..6bcb9569e 100644
--- a/ts41/pascal-cased-properties-deep.d.ts
+++ b/ts41/pascal-cased-properties-deep.d.ts
@@ -3,10 +3,11 @@ import {PascalCase} from './pascal-case';
 /**
 Convert object properties to pascal case recursively.
 
-This can be useful when, for example, converting some API types from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see PascalCase
 @see PascalCasedProperties
+
 @example
 ```
 interface User {

From bb94c63a82e076a57a2613a34b735ef23a8dc3c9 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:07:47 +0700
Subject: [PATCH 33/41] Update pascal-cased-properties.d.ts

---
 ts41/pascal-cased-properties.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ts41/pascal-cased-properties.d.ts b/ts41/pascal-cased-properties.d.ts
index f04e30841..f4f8394e3 100644
--- a/ts41/pascal-cased-properties.d.ts
+++ b/ts41/pascal-cased-properties.d.ts
@@ -3,10 +3,11 @@ import {PascalCase} from './pascal-case';
 /**
 Convert object properties to pascal case but not recursively.
 
-This can be useful when, for example, converting some api type from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see PascalCase
 @see PascalCasedPropertiesDeep
+
 @example
 ```
 interface User {

From 3ad02a4c1d91a892b55e8694d25a1ede63844174 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:08:02 +0700
Subject: [PATCH 34/41] Update snake-cased-properties-deep.d.ts

---
 ts41/snake-cased-properties-deep.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ts41/snake-cased-properties-deep.d.ts b/ts41/snake-cased-properties-deep.d.ts
index 6203b3d75..fb822a51e 100644
--- a/ts41/snake-cased-properties-deep.d.ts
+++ b/ts41/snake-cased-properties-deep.d.ts
@@ -3,10 +3,11 @@ import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 /**
 Convert object properties to snake case recursively.
 
-This can be useful when, for example, converting some API types from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see SnakeCase
 @see SnakeCasedProperties
+
 @example
 ```
 interface User {

From 8f36e3a51dbddc3530ca94cd27017331b8231b71 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:08:10 +0700
Subject: [PATCH 35/41] Update snake-cased-properties.d.ts

---
 ts41/snake-cased-properties.d.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/ts41/snake-cased-properties.d.ts b/ts41/snake-cased-properties.d.ts
index 7e9709a4f..6305ba894 100644
--- a/ts41/snake-cased-properties.d.ts
+++ b/ts41/snake-cased-properties.d.ts
@@ -3,10 +3,11 @@ import {DelimiterCasedProperties} from './delimiter-cased-properties';
 /**
 Convert object properties to snake case but not recursively.
 
-This can be useful when, for example, converting some api type from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see SnakeCase
 @see SnakeCasedPropertiesDeep
+
 @example
 ```
 interface User {

From 8218fbe8cc9276e251e43541862b4fbe5196eedd Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:09:17 +0700
Subject: [PATCH 36/41] Update camel-cased-properties-deep.d.ts

---
 ts41/camel-cased-properties-deep.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts41/camel-cased-properties-deep.d.ts b/ts41/camel-cased-properties-deep.d.ts
index 0a44661f5..7117a75b4 100644
--- a/ts41/camel-cased-properties-deep.d.ts
+++ b/ts41/camel-cased-properties-deep.d.ts
@@ -3,7 +3,7 @@ import {CamelCase} from './camel-case';
 /**
 Convert object properties to camel case recursively.
 
-This can be useful when, for example, converting some API types from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see CamelCasedProperties
 @see CamelCase

From 403fa339e2d59dcff2dbcee79993c46c0f39bedb Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:09:22 +0700
Subject: [PATCH 37/41] Update camel-cased-properties.d.ts

---
 ts41/camel-cased-properties.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts41/camel-cased-properties.d.ts b/ts41/camel-cased-properties.d.ts
index 574b74e89..ca315952c 100644
--- a/ts41/camel-cased-properties.d.ts
+++ b/ts41/camel-cased-properties.d.ts
@@ -3,7 +3,7 @@ import {CamelCase} from './camel-case';
 /**
 Convert object properties to camel case but not recursively.
 
-This can be useful when, for example, converting some api type from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see CamelCasedPropertiesDeep
 @see CamelCase

From 2de59f0933c35cd778a0ae44e463380ced05e00b Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:09:27 +0700
Subject: [PATCH 38/41] Update delimiter-cased-properties-deep.d.ts

---
 ts41/delimiter-cased-properties-deep.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts41/delimiter-cased-properties-deep.d.ts b/ts41/delimiter-cased-properties-deep.d.ts
index cf60a4b79..741c4ad8a 100644
--- a/ts41/delimiter-cased-properties-deep.d.ts
+++ b/ts41/delimiter-cased-properties-deep.d.ts
@@ -3,7 +3,7 @@ import {DelimiterCase} from './delimiter-case';
 /**
 Convert object properties to delimiter case recursively.
 
-This can be useful when, for example, converting some API types from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see DelimiterCase
 @see DelimiterCasedProperties

From 818788b5aad09b1a572f7a4d41d1c5261ceb55be Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:09:32 +0700
Subject: [PATCH 39/41] Update delimiter-cased-properties.d.ts

---
 ts41/delimiter-cased-properties.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts41/delimiter-cased-properties.d.ts b/ts41/delimiter-cased-properties.d.ts
index 316e404ef..8a108a665 100644
--- a/ts41/delimiter-cased-properties.d.ts
+++ b/ts41/delimiter-cased-properties.d.ts
@@ -3,7 +3,7 @@ import {DelimiterCase} from './delimiter-case';
 /**
 Convert object properties to delimiter case but not recursively.
 
-This can be useful when, for example, converting some api type from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see DelimiterCase
 @see DelimiterCasedPropertiesDeep

From c5389b7310c15d30d726973c6c960e6d6a33d368 Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:09:37 +0700
Subject: [PATCH 40/41] Update kebab-cased-properties-deep.d.ts

---
 ts41/kebab-cased-properties-deep.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts41/kebab-cased-properties-deep.d.ts b/ts41/kebab-cased-properties-deep.d.ts
index 91b81692f..cdca49945 100644
--- a/ts41/kebab-cased-properties-deep.d.ts
+++ b/ts41/kebab-cased-properties-deep.d.ts
@@ -3,7 +3,7 @@ import {DelimiterCasedPropertiesDeep} from './delimiter-cased-properties-deep';
 /**
 Convert object properties to kebab case recursively.
 
-This can be useful when, for example, converting some API types from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see KebabCase
 @see KebabCasedProperties

From 8c6dd2d463ddccf84ae1c5c3567b09314ddbe8fe Mon Sep 17 00:00:00 2001
From: Sindre Sorhus <sindresorhus@gmail.com>
Date: Mon, 22 Mar 2021 15:09:42 +0700
Subject: [PATCH 41/41] Update kebab-cased-properties.d.ts

---
 ts41/kebab-cased-properties.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ts41/kebab-cased-properties.d.ts b/ts41/kebab-cased-properties.d.ts
index fd0f2e26c..950cda5f7 100644
--- a/ts41/kebab-cased-properties.d.ts
+++ b/ts41/kebab-cased-properties.d.ts
@@ -3,7 +3,7 @@ import {DelimiterCasedProperties} from './delimiter-cased-properties';
 /**
 Convert object properties to kebab case but not recursively.
 
-This can be useful when, for example, converting some API type from other style.
+This can be useful when, for example, converting some API types from a different style.
 
 @see KebabCase
 @see KebabCasedPropertiesDeep