caseparser 3.0.0 → 4.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/index.d.ts CHANGED
@@ -1,6 +1,7 @@
1
- type CamelToDash<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? '-' : ''}${Lowercase<L>}${CamelToDash<R>}` : T;
1
+ //#region src/types.d.ts
2
+ type CamelToDash<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "-" : ""}${Lowercase<L>}${CamelToDash<R>}` : T;
2
3
  type CamelToPascal<T extends string> = Capitalize<T>;
3
- type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? '_' : ''}${Lowercase<L>}${CamelToSnake<R>}` : T;
4
+ type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "_" : ""}${Lowercase<L>}${CamelToSnake<R>}` : T;
4
5
  type CamelToUpperDash<T extends string> = Uppercase<CamelToDash<T>>;
5
6
  type CamelToUpperSnake<T extends string> = Uppercase<CamelToSnake<T>>;
6
7
  type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
@@ -28,49 +29,332 @@ type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
28
29
  type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
29
30
  type UpperSnakeToSnake<T extends string> = Lowercase<T>;
30
31
  type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
31
- type Prettify<T> = {
32
- [K in keyof T]: T[K];
33
- } & {};
34
- type Result<T, P> = T extends string ? string : T extends Array<unknown> ? {
35
- [K in keyof T]: Result<T[K], P>;
36
- } : T extends object ? Prettify<{
37
- [K in keyof T as P extends 'CamelToDash' ? CamelToDash<K & string> : P extends 'CamelToPascal' ? CamelToPascal<K & string> : P extends 'CamelToSnake' ? CamelToSnake<K & string> : P extends 'CamelToUpperDash' ? CamelToUpperDash<K & string> : P extends 'CamelToUpperSnake' ? CamelToUpperSnake<K & string> : P extends 'DashToCamel' ? DashToCamel<K & string> : P extends 'DashToPascal' ? DashToPascal<K & string> : P extends 'DashToSnake' ? DashToSnake<K & string> : P extends 'DashToUpperDash' ? DashToUpperDash<K & string> : P extends 'DashToUpperSnake' ? DashToUpperSnake<K & string> : P extends 'PascalToCamel' ? PascalToCamel<K & string> : P extends 'PascalToDash' ? PascalToDash<K & string> : P extends 'PascalToSnake' ? PascalToSnake<K & string> : P extends 'PascalToUpperDash' ? PascalToUpperDash<K & string> : P extends 'PascalToUpperSnake' ? PascalToUpperSnake<K & string> : P extends 'SnakeToCamel' ? SnakeToCamel<K & string> : P extends 'SnakeToDash' ? SnakeToDash<K & string> : P extends 'SnakeToPascal' ? SnakeToPascal<K & string> : P extends 'SnakeToUpperDash' ? SnakeToUpperDash<K & string> : P extends 'SnakeToUpperSnake' ? SnakeToUpperSnake<K & string> : P extends 'UpperDashToCamel' ? UpperDashToCamel<K & string> : P extends 'UpperDashToDash' ? UpperDashToDash<K & string> : P extends 'UpperDashToPascal' ? UpperDashToPascal<K & string> : P extends 'UpperDashToSnake' ? UpperDashToSnake<K & string> : P extends 'UpperDashToUpperSnake' ? UpperDashToUpperSnake<K & string> : P extends 'UpperSnakeToCamel' ? UpperSnakeToCamel<K & string> : P extends 'UpperSnakeToDash' ? UpperSnakeToDash<K & string> : P extends 'UpperSnakeToPascal' ? UpperSnakeToPascal<K & string> : P extends 'UpperSnakeToSnake' ? UpperSnakeToSnake<K & string> : P extends 'UpperSnakeToUpperDash' ? UpperSnakeToUpperDash<K & string> : never]: Result<T[K], P>;
38
- }> : T;
39
-
40
- declare function camelToDash<T extends object | string>(input: T): Result<T, "CamelToDash">;
41
- declare function camelToSnake<T extends object | string>(input: T): Result<T, "CamelToSnake">;
42
- declare function camelToPascal<T extends object | string>(input: T): Result<T, "CamelToPascal">;
43
- declare function camelToUpperSnake<T extends object | string>(input: T): Result<T, "CamelToUpperSnake">;
44
- declare function camelToUpperDash<T extends object | string>(input: T): Result<T, "CamelToUpperDash">;
45
-
46
- declare function dashToSnake<T extends object | string>(input: T): Result<T, "DashToSnake">;
47
- declare function dashToCamel<T extends object | string>(input: T): Result<T, "DashToCamel">;
48
- declare function dashToPascal<T extends object | string>(input: T): Result<T, "DashToPascal">;
49
- declare function dashToUpperSnake<T extends object | string>(input: T): Result<T, "DashToUpperSnake">;
50
- declare function dashToUpperDash<T extends object | string>(input: T): Result<T, "DashToUpperDash">;
51
-
52
- declare function pascalToCamel<T extends object | string>(input: T): Result<T, "PascalToCamel">;
53
- declare function pascalToSnake<T extends object | string>(input: T): Result<T, "PascalToSnake">;
54
- declare function pascalToDash<T extends object | string>(input: T): Result<T, "PascalToDash">;
55
- declare function pascalToUpperSnake<T extends object | string>(input: T): Result<T, "PascalToUpperSnake">;
56
- declare function pascalToUpperDash<T extends object | string>(input: T): Result<T, "PascalToUpperDash">;
57
-
58
- declare function snakeToCamel<T extends object | string>(input: T): Result<T, "SnakeToCamel">;
59
- declare function snakeToDash<T extends object | string>(input: T): Result<T, "SnakeToDash">;
60
- declare function snakeToPascal<T extends object | string>(input: T): Result<T, "SnakeToPascal">;
61
- declare function snakeToUpperSnake<T extends object | string>(input: T): Result<T, "SnakeToUpperSnake">;
62
- declare function snakeToUpperDash<T extends object | string>(input: T): Result<T, "SnakeToUpperDash">;
63
-
64
- declare function upperDashToCamel<T extends object | string>(input: T): Result<T, "UpperDashToCamel">;
65
- declare function upperDashToSnake<T extends object | string>(input: T): Result<T, "UpperDashToSnake">;
66
- declare function upperDashToDash<T extends object | string>(input: T): Result<T, "UpperDashToDash">;
67
- declare function upperDashToPascal<T extends object | string>(input: T): Result<T, "UpperDashToPascal">;
68
- declare function upperDashToUpperSnake<T extends object | string>(input: T): Result<T, "UpperDashToUpperSnake">;
69
-
70
- declare function upperSnakeToCamel<T extends object | string>(input: T): Result<T, "UpperSnakeToCamel">;
71
- declare function upperSnakeToSnake<T extends object | string>(input: T): Result<T, "UpperSnakeToSnake">;
72
- declare function upperSnakeToDash<T extends object | string>(input: T): Result<T, "UpperSnakeToDash">;
73
- declare function upperSnakeToPascal<T extends object | string>(input: T): Result<T, "UpperSnakeToPascal">;
74
- declare function upperSnakeToUpperDash<T extends object | string>(input: T): Result<T, "UpperSnakeToUpperDash">;
75
-
76
- export { camelToDash, camelToPascal, camelToSnake, camelToUpperDash, camelToUpperSnake, dashToCamel, dashToPascal, dashToSnake, dashToUpperDash, dashToUpperSnake, pascalToCamel, pascalToDash, pascalToSnake, pascalToUpperDash, pascalToUpperSnake, snakeToCamel, snakeToDash, snakeToPascal, snakeToUpperDash, snakeToUpperSnake, upperDashToCamel, upperDashToDash, upperDashToPascal, upperDashToSnake, upperDashToUpperSnake, upperSnakeToCamel, upperSnakeToDash, upperSnakeToPascal, upperSnakeToSnake, upperSnakeToUpperDash };
32
+ type ParserCamelType = "CamelToDash" | "CamelToPascal" | "CamelToSnake" | "CamelToUpperDash" | "CamelToUpperSnake";
33
+ type ParserDashType = "DashToCamel" | "DashToPascal" | "DashToSnake" | "DashToUpperDash" | "DashToUpperSnake";
34
+ type ParserPascalType = "PascalToCamel" | "PascalToDash" | "PascalToSnake" | "PascalToUpperDash" | "PascalToUpperSnake";
35
+ type ParserSnakeType = "SnakeToCamel" | "SnakeToDash" | "SnakeToPascal" | "SnakeToUpperDash" | "SnakeToUpperSnake";
36
+ type ParserUpperDashType = "UpperDashToCamel" | "UpperDashToDash" | "UpperDashToPascal" | "UpperDashToSnake" | "UpperDashToUpperSnake";
37
+ type ParserUpperSnakeType = "UpperSnakeToCamel" | "UpperSnakeToDash" | "UpperSnakeToPascal" | "UpperSnakeToSnake" | "UpperSnakeToUpperDash";
38
+ /** Identifies a conversion, e.g. `'CamelToSnake'`. */
39
+ type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType;
40
+ /** Flattens an intersection/mapped type so editors show the resulting keys. */
41
+ type Prettify<T> = { [K in keyof T]: T[K]; } & {};
42
+ /**
43
+ * The type returned by a conversion: strings stay `string`, and object keys
44
+ * (deeply, including inside arrays) are renamed according to the conversion `P`.
45
+ */
46
+ type Result<T, P> = T extends string ? string : T extends Array<unknown> ? { [K in keyof T]: Result<T[K], P>; } : T extends object ? Prettify<{ [K in keyof T as P extends "CamelToDash" ? CamelToDash<K & string> : P extends "CamelToPascal" ? CamelToPascal<K & string> : P extends "CamelToSnake" ? CamelToSnake<K & string> : P extends "CamelToUpperDash" ? CamelToUpperDash<K & string> : P extends "CamelToUpperSnake" ? CamelToUpperSnake<K & string> : P extends "DashToCamel" ? DashToCamel<K & string> : P extends "DashToPascal" ? DashToPascal<K & string> : P extends "DashToSnake" ? DashToSnake<K & string> : P extends "DashToUpperDash" ? DashToUpperDash<K & string> : P extends "DashToUpperSnake" ? DashToUpperSnake<K & string> : P extends "PascalToCamel" ? PascalToCamel<K & string> : P extends "PascalToDash" ? PascalToDash<K & string> : P extends "PascalToSnake" ? PascalToSnake<K & string> : P extends "PascalToUpperDash" ? PascalToUpperDash<K & string> : P extends "PascalToUpperSnake" ? PascalToUpperSnake<K & string> : P extends "SnakeToCamel" ? SnakeToCamel<K & string> : P extends "SnakeToDash" ? SnakeToDash<K & string> : P extends "SnakeToPascal" ? SnakeToPascal<K & string> : P extends "SnakeToUpperDash" ? SnakeToUpperDash<K & string> : P extends "SnakeToUpperSnake" ? SnakeToUpperSnake<K & string> : P extends "UpperDashToCamel" ? UpperDashToCamel<K & string> : P extends "UpperDashToDash" ? UpperDashToDash<K & string> : P extends "UpperDashToPascal" ? UpperDashToPascal<K & string> : P extends "UpperDashToSnake" ? UpperDashToSnake<K & string> : P extends "UpperDashToUpperSnake" ? UpperDashToUpperSnake<K & string> : P extends "UpperSnakeToCamel" ? UpperSnakeToCamel<K & string> : P extends "UpperSnakeToDash" ? UpperSnakeToDash<K & string> : P extends "UpperSnakeToPascal" ? UpperSnakeToPascal<K & string> : P extends "UpperSnakeToSnake" ? UpperSnakeToSnake<K & string> : P extends "UpperSnakeToUpperDash" ? UpperSnakeToUpperDash<K & string> : never]: Result<T[K], P>; }> : T;
47
+ //#endregion
48
+ //#region src/camelCase/camelCase.d.ts
49
+ /**
50
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to dash-case.
51
+ *
52
+ * @example
53
+ * ```ts
54
+ * camelToDash('helloWorld'); // 'hello-world'
55
+ * camelToDash({ firstName: 'John' }); // { 'first-name': 'John' }
56
+ * ```
57
+ */
58
+ export declare function camelToDash<T extends object | string>(input: T): Result<T, "CamelToDash">;
59
+ /**
60
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to snake_case.
61
+ *
62
+ * @example
63
+ * ```ts
64
+ * camelToSnake('helloWorld'); // 'hello_world'
65
+ * camelToSnake({ firstName: 'John' }); // { first_name: 'John' }
66
+ * ```
67
+ */
68
+ export declare function camelToSnake<T extends object | string>(input: T): Result<T, "CamelToSnake">;
69
+ /**
70
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to PascalCase.
71
+ *
72
+ * @example
73
+ * ```ts
74
+ * camelToPascal('helloWorld'); // 'HelloWorld'
75
+ * camelToPascal({ firstName: 'John' }); // { FirstName: 'John' }
76
+ * ```
77
+ */
78
+ export declare function camelToPascal<T extends object | string>(input: T): Result<T, "CamelToPascal">;
79
+ /**
80
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER_SNAKE_CASE.
81
+ *
82
+ * @example
83
+ * ```ts
84
+ * camelToUpperSnake('helloWorld'); // 'HELLO_WORLD'
85
+ * camelToUpperSnake({ firstName: 'John' }); // { FIRST_NAME: 'John' }
86
+ * ```
87
+ */
88
+ export declare function camelToUpperSnake<T extends object | string>(input: T): Result<T, "CamelToUpperSnake">;
89
+ /**
90
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER-DASH-CASE.
91
+ *
92
+ * @example
93
+ * ```ts
94
+ * camelToUpperDash('helloWorld'); // 'HELLO-WORLD'
95
+ * camelToUpperDash({ firstName: 'John' }); // { 'FIRST-NAME': 'John' }
96
+ * ```
97
+ */
98
+ export declare function camelToUpperDash<T extends object | string>(input: T): Result<T, "CamelToUpperDash">;
99
+ //#endregion
100
+ //#region src/dashCase/dashCase.d.ts
101
+ /**
102
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to snake_case.
103
+ *
104
+ * @example
105
+ * ```ts
106
+ * dashToSnake('hello-world'); // 'hello_world'
107
+ * dashToSnake({ 'first-name': 'John' }); // { first_name: 'John' }
108
+ * ```
109
+ */
110
+ export declare function dashToSnake<T extends object | string>(input: T): Result<T, "DashToSnake">;
111
+ /**
112
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to camelCase.
113
+ *
114
+ * @example
115
+ * ```ts
116
+ * dashToCamel('hello-world'); // 'helloWorld'
117
+ * dashToCamel({ 'first-name': 'John' }); // { firstName: 'John' }
118
+ * ```
119
+ */
120
+ export declare function dashToCamel<T extends object | string>(input: T): Result<T, "DashToCamel">;
121
+ /**
122
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to PascalCase.
123
+ *
124
+ * @example
125
+ * ```ts
126
+ * dashToPascal('hello-world'); // 'HelloWorld'
127
+ * dashToPascal({ 'first-name': 'John' }); // { FirstName: 'John' }
128
+ * ```
129
+ */
130
+ export declare function dashToPascal<T extends object | string>(input: T): Result<T, "DashToPascal">;
131
+ /**
132
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER_SNAKE_CASE.
133
+ *
134
+ * @example
135
+ * ```ts
136
+ * dashToUpperSnake('hello-world'); // 'HELLO_WORLD'
137
+ * dashToUpperSnake({ 'first-name': 'John' }); // { FIRST_NAME: 'John' }
138
+ * ```
139
+ */
140
+ export declare function dashToUpperSnake<T extends object | string>(input: T): Result<T, "DashToUpperSnake">;
141
+ /**
142
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER-DASH-CASE.
143
+ *
144
+ * @example
145
+ * ```ts
146
+ * dashToUpperDash('hello-world'); // 'HELLO-WORLD'
147
+ * dashToUpperDash({ 'first-name': 'John' }); // { 'FIRST-NAME': 'John' }
148
+ * ```
149
+ */
150
+ export declare function dashToUpperDash<T extends object | string>(input: T): Result<T, "DashToUpperDash">;
151
+ //#endregion
152
+ //#region src/pascalCase/pascalCase.d.ts
153
+ /**
154
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to camelCase.
155
+ *
156
+ * @example
157
+ * ```ts
158
+ * pascalToCamel('HelloWorld'); // 'helloWorld'
159
+ * pascalToCamel({ FirstName: 'John' }); // { firstName: 'John' }
160
+ * ```
161
+ */
162
+ export declare function pascalToCamel<T extends object | string>(input: T): Result<T, "PascalToCamel">;
163
+ /**
164
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to snake_case.
165
+ *
166
+ * @example
167
+ * ```ts
168
+ * pascalToSnake('HelloWorld'); // 'hello_world'
169
+ * pascalToSnake({ FirstName: 'John' }); // { first_name: 'John' }
170
+ * ```
171
+ */
172
+ export declare function pascalToSnake<T extends object | string>(input: T): Result<T, "PascalToSnake">;
173
+ /**
174
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to dash-case.
175
+ *
176
+ * @example
177
+ * ```ts
178
+ * pascalToDash('HelloWorld'); // 'hello-world'
179
+ * pascalToDash({ FirstName: 'John' }); // { 'first-name': 'John' }
180
+ * ```
181
+ */
182
+ export declare function pascalToDash<T extends object | string>(input: T): Result<T, "PascalToDash">;
183
+ /**
184
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER_SNAKE_CASE.
185
+ *
186
+ * @example
187
+ * ```ts
188
+ * pascalToUpperSnake('HelloWorld'); // 'HELLO_WORLD'
189
+ * pascalToUpperSnake({ FirstName: 'John' }); // { FIRST_NAME: 'John' }
190
+ * ```
191
+ */
192
+ export declare function pascalToUpperSnake<T extends object | string>(input: T): Result<T, "PascalToUpperSnake">;
193
+ /**
194
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER-DASH-CASE.
195
+ *
196
+ * @example
197
+ * ```ts
198
+ * pascalToUpperDash('HelloWorld'); // 'HELLO-WORLD'
199
+ * pascalToUpperDash({ FirstName: 'John' }); // { 'FIRST-NAME': 'John' }
200
+ * ```
201
+ */
202
+ export declare function pascalToUpperDash<T extends object | string>(input: T): Result<T, "PascalToUpperDash">;
203
+ //#endregion
204
+ //#region src/snakeCase/snakeCase.d.ts
205
+ /**
206
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to camelCase.
207
+ *
208
+ * @example
209
+ * ```ts
210
+ * snakeToCamel('hello_world'); // 'helloWorld'
211
+ * snakeToCamel({ first_name: 'John' }); // { firstName: 'John' }
212
+ * ```
213
+ */
214
+ export declare function snakeToCamel<T extends object | string>(input: T): Result<T, "SnakeToCamel">;
215
+ /**
216
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to dash-case.
217
+ *
218
+ * @example
219
+ * ```ts
220
+ * snakeToDash('hello_world'); // 'hello-world'
221
+ * snakeToDash({ first_name: 'John' }); // { 'first-name': 'John' }
222
+ * ```
223
+ */
224
+ export declare function snakeToDash<T extends object | string>(input: T): Result<T, "SnakeToDash">;
225
+ /**
226
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to PascalCase.
227
+ *
228
+ * @example
229
+ * ```ts
230
+ * snakeToPascal('hello_world'); // 'HelloWorld'
231
+ * snakeToPascal({ first_name: 'John' }); // { FirstName: 'John' }
232
+ * ```
233
+ */
234
+ export declare function snakeToPascal<T extends object | string>(input: T): Result<T, "SnakeToPascal">;
235
+ /**
236
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER_SNAKE_CASE.
237
+ *
238
+ * @example
239
+ * ```ts
240
+ * snakeToUpperSnake('hello_world'); // 'HELLO_WORLD'
241
+ * snakeToUpperSnake({ first_name: 'John' }); // { FIRST_NAME: 'John' }
242
+ * ```
243
+ */
244
+ export declare function snakeToUpperSnake<T extends object | string>(input: T): Result<T, "SnakeToUpperSnake">;
245
+ /**
246
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER-DASH-CASE.
247
+ *
248
+ * @example
249
+ * ```ts
250
+ * snakeToUpperDash('hello_world'); // 'HELLO-WORLD'
251
+ * snakeToUpperDash({ first_name: 'John' }); // { 'FIRST-NAME': 'John' }
252
+ * ```
253
+ */
254
+ export declare function snakeToUpperDash<T extends object | string>(input: T): Result<T, "SnakeToUpperDash">;
255
+ //#endregion
256
+ //#region src/upperDashCase/upperDashCase.d.ts
257
+ /**
258
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to camelCase.
259
+ *
260
+ * @example
261
+ * ```ts
262
+ * upperDashToCamel('HELLO-WORLD'); // 'helloWorld'
263
+ * upperDashToCamel({ 'FIRST-NAME': 'John' }); // { firstName: 'John' }
264
+ * ```
265
+ */
266
+ export declare function upperDashToCamel<T extends object | string>(input: T): Result<T, "UpperDashToCamel">;
267
+ /**
268
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to snake_case.
269
+ *
270
+ * @example
271
+ * ```ts
272
+ * upperDashToSnake('HELLO-WORLD'); // 'hello_world'
273
+ * upperDashToSnake({ 'FIRST-NAME': 'John' }); // { first_name: 'John' }
274
+ * ```
275
+ */
276
+ export declare function upperDashToSnake<T extends object | string>(input: T): Result<T, "UpperDashToSnake">;
277
+ /**
278
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to dash-case.
279
+ *
280
+ * @example
281
+ * ```ts
282
+ * upperDashToDash('HELLO-WORLD'); // 'hello-world'
283
+ * upperDashToDash({ 'FIRST-NAME': 'John' }); // { 'first-name': 'John' }
284
+ * ```
285
+ */
286
+ export declare function upperDashToDash<T extends object | string>(input: T): Result<T, "UpperDashToDash">;
287
+ /**
288
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to PascalCase.
289
+ *
290
+ * @example
291
+ * ```ts
292
+ * upperDashToPascal('HELLO-WORLD'); // 'HelloWorld'
293
+ * upperDashToPascal({ 'FIRST-NAME': 'John' }); // { FirstName: 'John' }
294
+ * ```
295
+ */
296
+ export declare function upperDashToPascal<T extends object | string>(input: T): Result<T, "UpperDashToPascal">;
297
+ /**
298
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to UPPER_SNAKE_CASE.
299
+ *
300
+ * @example
301
+ * ```ts
302
+ * upperDashToUpperSnake('HELLO-WORLD'); // 'HELLO_WORLD'
303
+ * upperDashToUpperSnake({ 'FIRST-NAME': 'John' }); // { FIRST_NAME: 'John' }
304
+ * ```
305
+ */
306
+ export declare function upperDashToUpperSnake<T extends object | string>(input: T): Result<T, "UpperDashToUpperSnake">;
307
+ //#endregion
308
+ //#region src/upperSnakeCase/upperSnakeCase.d.ts
309
+ /**
310
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to camelCase.
311
+ *
312
+ * @example
313
+ * ```ts
314
+ * upperSnakeToCamel('HELLO_WORLD'); // 'helloWorld'
315
+ * upperSnakeToCamel({ FIRST_NAME: 'John' }); // { firstName: 'John' }
316
+ * ```
317
+ */
318
+ export declare function upperSnakeToCamel<T extends object | string>(input: T): Result<T, "UpperSnakeToCamel">;
319
+ /**
320
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to snake_case.
321
+ *
322
+ * @example
323
+ * ```ts
324
+ * upperSnakeToSnake('HELLO_WORLD'); // 'hello_world'
325
+ * upperSnakeToSnake({ FIRST_NAME: 'John' }); // { first_name: 'John' }
326
+ * ```
327
+ */
328
+ export declare function upperSnakeToSnake<T extends object | string>(input: T): Result<T, "UpperSnakeToSnake">;
329
+ /**
330
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to dash-case.
331
+ *
332
+ * @example
333
+ * ```ts
334
+ * upperSnakeToDash('HELLO_WORLD'); // 'hello-world'
335
+ * upperSnakeToDash({ FIRST_NAME: 'John' }); // { 'first-name': 'John' }
336
+ * ```
337
+ */
338
+ export declare function upperSnakeToDash<T extends object | string>(input: T): Result<T, "UpperSnakeToDash">;
339
+ /**
340
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to PascalCase.
341
+ *
342
+ * @example
343
+ * ```ts
344
+ * upperSnakeToPascal('HELLO_WORLD'); // 'HelloWorld'
345
+ * upperSnakeToPascal({ FIRST_NAME: 'John' }); // { FirstName: 'John' }
346
+ * ```
347
+ */
348
+ export declare function upperSnakeToPascal<T extends object | string>(input: T): Result<T, "UpperSnakeToPascal">;
349
+ /**
350
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to UPPER-DASH-CASE.
351
+ *
352
+ * @example
353
+ * ```ts
354
+ * upperSnakeToUpperDash('HELLO_WORLD'); // 'HELLO-WORLD'
355
+ * upperSnakeToUpperDash({ FIRST_NAME: 'John' }); // { 'FIRST-NAME': 'John' }
356
+ * ```
357
+ */
358
+ export declare function upperSnakeToUpperDash<T extends object | string>(input: T): Result<T, "UpperSnakeToUpperDash">;
359
+ //#endregion
360
+ export type { ParserType, Prettify, Result };