caseparser 3.0.0 → 4.1.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.
@@ -0,0 +1,652 @@
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;
3
+ type CamelToPascal<T extends string> = Capitalize<T>;
4
+ type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "_" : ""}${Lowercase<L>}${CamelToSnake<R>}` : T;
5
+ type CamelToUpperDash<T extends string> = Uppercase<CamelToDash<T>>;
6
+ type CamelToUpperSnake<T extends string> = Uppercase<CamelToSnake<T>>;
7
+ type CamelToTrain<T extends string> = DashToTrain<CamelToDash<T>>;
8
+ type CamelToDot<T extends string> = DashToDot<CamelToDash<T>>;
9
+ type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
10
+ type DashToPascal<T extends string> = Capitalize<DashToCamel<T>>;
11
+ type DashToSnake<T extends string> = T extends `${infer L}-${infer R}` ? `${L}_${DashToSnake<R>}` : T;
12
+ type DashToUpperDash<T extends string> = Uppercase<T>;
13
+ type DashToUpperSnake<T extends string> = Uppercase<DashToSnake<T>>;
14
+ type DashToTrain<T extends string> = T extends `${infer L}-${infer R}` ? `${Capitalize<L>}-${DashToTrain<R>}` : Capitalize<T>;
15
+ type DashToDot<T extends string> = T extends `${infer L}-${infer R}` ? `${L}.${DashToDot<R>}` : T;
16
+ type PascalToCamel<T extends string> = Uncapitalize<T>;
17
+ type PascalToDash<T extends string> = CamelToDash<Uncapitalize<T>>;
18
+ type PascalToSnake<T extends string> = CamelToSnake<Uncapitalize<T>>;
19
+ type PascalToUpperDash<T extends string> = Uppercase<PascalToDash<T>>;
20
+ type PascalToUpperSnake<T extends string> = Uppercase<PascalToSnake<T>>;
21
+ type PascalToTrain<T extends string> = DashToTrain<PascalToDash<T>>;
22
+ type PascalToDot<T extends string> = DashToDot<PascalToDash<T>>;
23
+ type SnakeToCamel<T extends string> = T extends `${infer L}_${infer R}` ? `${L}${Capitalize<SnakeToCamel<R>>}` : T;
24
+ type SnakeToDash<T extends string> = T extends `${infer L}_${infer R}` ? `${L}-${SnakeToDash<R>}` : T;
25
+ type SnakeToPascal<T extends string> = Capitalize<SnakeToCamel<T>>;
26
+ type SnakeToUpperDash<T extends string> = Uppercase<SnakeToDash<T>>;
27
+ type SnakeToUpperSnake<T extends string> = Uppercase<T>;
28
+ type SnakeToTrain<T extends string> = DashToTrain<SnakeToDash<T>>;
29
+ type SnakeToDot<T extends string> = DashToDot<SnakeToDash<T>>;
30
+ type UpperDashToCamel<T extends string> = DashToCamel<Lowercase<T>>;
31
+ type UpperDashToDash<T extends string> = Lowercase<T>;
32
+ type UpperDashToPascal<T extends string> = Capitalize<UpperDashToCamel<T>>;
33
+ type UpperDashToSnake<T extends string> = DashToSnake<UpperDashToDash<T>>;
34
+ type UpperDashToUpperSnake<T extends string> = Uppercase<UpperDashToSnake<T>>;
35
+ type UpperDashToTrain<T extends string> = DashToTrain<UpperDashToDash<T>>;
36
+ type UpperDashToDot<T extends string> = DashToDot<UpperDashToDash<T>>;
37
+ type UpperSnakeToCamel<T extends string> = SnakeToCamel<Lowercase<T>>;
38
+ type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
39
+ type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
40
+ type UpperSnakeToSnake<T extends string> = Lowercase<T>;
41
+ type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
42
+ type UpperSnakeToTrain<T extends string> = DashToTrain<UpperSnakeToDash<T>>;
43
+ type UpperSnakeToDot<T extends string> = DashToDot<UpperSnakeToDash<T>>;
44
+ type TrainToCamel<T extends string> = DashToCamel<TrainToDash<T>>;
45
+ type TrainToDash<T extends string> = Lowercase<T>;
46
+ type TrainToDot<T extends string> = DashToDot<TrainToDash<T>>;
47
+ type TrainToPascal<T extends string> = DashToPascal<TrainToDash<T>>;
48
+ type TrainToSnake<T extends string> = DashToSnake<TrainToDash<T>>;
49
+ type TrainToUpperDash<T extends string> = Uppercase<T>;
50
+ type TrainToUpperSnake<T extends string> = DashToUpperSnake<TrainToDash<T>>;
51
+ type DotToCamel<T extends string> = DashToCamel<DotToDash<T>>;
52
+ type DotToDash<T extends string> = T extends `${infer L}.${infer R}` ? `${L}-${DotToDash<R>}` : T;
53
+ type DotToPascal<T extends string> = DashToPascal<DotToDash<T>>;
54
+ type DotToSnake<T extends string> = DashToSnake<DotToDash<T>>;
55
+ type DotToTrain<T extends string> = DashToTrain<DotToDash<T>>;
56
+ type DotToUpperDash<T extends string> = Uppercase<DotToDash<T>>;
57
+ type DotToUpperSnake<T extends string> = DashToUpperSnake<DotToDash<T>>;
58
+ type ParserCamelType = "CamelToDash" | "CamelToPascal" | "CamelToSnake" | "CamelToUpperDash" | "CamelToUpperSnake" | "CamelToTrain" | "CamelToDot";
59
+ type ParserDashType = "DashToCamel" | "DashToPascal" | "DashToSnake" | "DashToUpperDash" | "DashToUpperSnake" | "DashToTrain" | "DashToDot";
60
+ type ParserPascalType = "PascalToCamel" | "PascalToDash" | "PascalToSnake" | "PascalToUpperDash" | "PascalToUpperSnake" | "PascalToTrain" | "PascalToDot";
61
+ type ParserSnakeType = "SnakeToCamel" | "SnakeToDash" | "SnakeToPascal" | "SnakeToUpperDash" | "SnakeToUpperSnake" | "SnakeToTrain" | "SnakeToDot";
62
+ type ParserUpperDashType = "UpperDashToCamel" | "UpperDashToDash" | "UpperDashToPascal" | "UpperDashToSnake" | "UpperDashToUpperSnake" | "UpperDashToTrain" | "UpperDashToDot";
63
+ type ParserUpperSnakeType = "UpperSnakeToCamel" | "UpperSnakeToDash" | "UpperSnakeToPascal" | "UpperSnakeToSnake" | "UpperSnakeToUpperDash" | "UpperSnakeToTrain" | "UpperSnakeToDot";
64
+ type ParserTrainType = "TrainToCamel" | "TrainToDash" | "TrainToDot" | "TrainToPascal" | "TrainToSnake" | "TrainToUpperDash" | "TrainToUpperSnake";
65
+ type ParserDotType = "DotToCamel" | "DotToDash" | "DotToPascal" | "DotToSnake" | "DotToTrain" | "DotToUpperDash" | "DotToUpperSnake";
66
+ /** Identifies a conversion, e.g. `'CamelToSnake'`. */
67
+ type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType | ParserTrainType | ParserDotType;
68
+ /** Flattens an intersection/mapped type so editors show the resulting keys. */
69
+ type Prettify<T> = { [K in keyof T]: T[K]; } & {};
70
+ /**
71
+ * The type returned by a conversion: strings stay `string`, and object keys
72
+ * (deeply, including inside arrays) are renamed according to the conversion `P`.
73
+ */
74
+ 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> : P extends "CamelToTrain" ? CamelToTrain<K & string> : P extends "CamelToDot" ? CamelToDot<K & string> : P extends "PascalToTrain" ? PascalToTrain<K & string> : P extends "PascalToDot" ? PascalToDot<K & string> : P extends "SnakeToTrain" ? SnakeToTrain<K & string> : P extends "SnakeToDot" ? SnakeToDot<K & string> : P extends "DashToTrain" ? DashToTrain<K & string> : P extends "DashToDot" ? DashToDot<K & string> : P extends "UpperSnakeToTrain" ? UpperSnakeToTrain<K & string> : P extends "UpperSnakeToDot" ? UpperSnakeToDot<K & string> : P extends "UpperDashToTrain" ? UpperDashToTrain<K & string> : P extends "UpperDashToDot" ? UpperDashToDot<K & string> : P extends "TrainToCamel" ? TrainToCamel<K & string> : P extends "TrainToPascal" ? TrainToPascal<K & string> : P extends "TrainToSnake" ? TrainToSnake<K & string> : P extends "TrainToDash" ? TrainToDash<K & string> : P extends "TrainToUpperSnake" ? TrainToUpperSnake<K & string> : P extends "TrainToUpperDash" ? TrainToUpperDash<K & string> : P extends "TrainToDot" ? TrainToDot<K & string> : P extends "DotToCamel" ? DotToCamel<K & string> : P extends "DotToPascal" ? DotToPascal<K & string> : P extends "DotToSnake" ? DotToSnake<K & string> : P extends "DotToDash" ? DotToDash<K & string> : P extends "DotToUpperSnake" ? DotToUpperSnake<K & string> : P extends "DotToUpperDash" ? DotToUpperDash<K & string> : P extends "DotToTrain" ? DotToTrain<K & string> : never]: Result<T[K], P>; }> : T;
75
+ //#endregion
76
+ //#region src/camelCase/camelCase.d.ts
77
+ /**
78
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to dash-case.
79
+ *
80
+ * @example
81
+ * ```ts
82
+ * camelToDash('helloWorld'); // 'hello-world'
83
+ * camelToDash({ firstName: 'John' }); // { 'first-name': 'John' }
84
+ * ```
85
+ */
86
+ export declare function camelToDash<T extends object | string>(input: T): Result<T, "CamelToDash">;
87
+ /**
88
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to snake_case.
89
+ *
90
+ * @example
91
+ * ```ts
92
+ * camelToSnake('helloWorld'); // 'hello_world'
93
+ * camelToSnake({ firstName: 'John' }); // { first_name: 'John' }
94
+ * ```
95
+ */
96
+ export declare function camelToSnake<T extends object | string>(input: T): Result<T, "CamelToSnake">;
97
+ /**
98
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to PascalCase.
99
+ *
100
+ * @example
101
+ * ```ts
102
+ * camelToPascal('helloWorld'); // 'HelloWorld'
103
+ * camelToPascal({ firstName: 'John' }); // { FirstName: 'John' }
104
+ * ```
105
+ */
106
+ export declare function camelToPascal<T extends object | string>(input: T): Result<T, "CamelToPascal">;
107
+ /**
108
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER_SNAKE_CASE.
109
+ *
110
+ * @example
111
+ * ```ts
112
+ * camelToUpperSnake('helloWorld'); // 'HELLO_WORLD'
113
+ * camelToUpperSnake({ firstName: 'John' }); // { FIRST_NAME: 'John' }
114
+ * ```
115
+ */
116
+ export declare function camelToUpperSnake<T extends object | string>(input: T): Result<T, "CamelToUpperSnake">;
117
+ /**
118
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to UPPER-DASH-CASE.
119
+ *
120
+ * @example
121
+ * ```ts
122
+ * camelToUpperDash('helloWorld'); // 'HELLO-WORLD'
123
+ * camelToUpperDash({ firstName: 'John' }); // { 'FIRST-NAME': 'John' }
124
+ * ```
125
+ */
126
+ export declare function camelToUpperDash<T extends object | string>(input: T): Result<T, "CamelToUpperDash">;
127
+ /**
128
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to Train-Case.
129
+ *
130
+ * @example
131
+ * ```ts
132
+ * camelToTrain('helloWorld'); // 'Hello-World'
133
+ * camelToTrain({ firstName: 'John' }); // { 'First-Name': 'John' }
134
+ * ```
135
+ */
136
+ export declare function camelToTrain<T extends object | string>(input: T): Result<T, "CamelToTrain">;
137
+ /**
138
+ * Converts a string, or the keys of an object/array (deeply), from camelCase to dot.case.
139
+ *
140
+ * @example
141
+ * ```ts
142
+ * camelToDot('helloWorld'); // 'hello.world'
143
+ * camelToDot({ firstName: 'John' }); // { 'first.name': 'John' }
144
+ * ```
145
+ */
146
+ export declare function camelToDot<T extends object | string>(input: T): Result<T, "CamelToDot">;
147
+ //#endregion
148
+ //#region src/dashCase/dashCase.d.ts
149
+ /**
150
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to snake_case.
151
+ *
152
+ * @example
153
+ * ```ts
154
+ * dashToSnake('hello-world'); // 'hello_world'
155
+ * dashToSnake({ 'first-name': 'John' }); // { first_name: 'John' }
156
+ * ```
157
+ */
158
+ export declare function dashToSnake<T extends object | string>(input: T): Result<T, "DashToSnake">;
159
+ /**
160
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to camelCase.
161
+ *
162
+ * @example
163
+ * ```ts
164
+ * dashToCamel('hello-world'); // 'helloWorld'
165
+ * dashToCamel({ 'first-name': 'John' }); // { firstName: 'John' }
166
+ * ```
167
+ */
168
+ export declare function dashToCamel<T extends object | string>(input: T): Result<T, "DashToCamel">;
169
+ /**
170
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to PascalCase.
171
+ *
172
+ * @example
173
+ * ```ts
174
+ * dashToPascal('hello-world'); // 'HelloWorld'
175
+ * dashToPascal({ 'first-name': 'John' }); // { FirstName: 'John' }
176
+ * ```
177
+ */
178
+ export declare function dashToPascal<T extends object | string>(input: T): Result<T, "DashToPascal">;
179
+ /**
180
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER_SNAKE_CASE.
181
+ *
182
+ * @example
183
+ * ```ts
184
+ * dashToUpperSnake('hello-world'); // 'HELLO_WORLD'
185
+ * dashToUpperSnake({ 'first-name': 'John' }); // { FIRST_NAME: 'John' }
186
+ * ```
187
+ */
188
+ export declare function dashToUpperSnake<T extends object | string>(input: T): Result<T, "DashToUpperSnake">;
189
+ /**
190
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to UPPER-DASH-CASE.
191
+ *
192
+ * @example
193
+ * ```ts
194
+ * dashToUpperDash('hello-world'); // 'HELLO-WORLD'
195
+ * dashToUpperDash({ 'first-name': 'John' }); // { 'FIRST-NAME': 'John' }
196
+ * ```
197
+ */
198
+ export declare function dashToUpperDash<T extends object | string>(input: T): Result<T, "DashToUpperDash">;
199
+ /**
200
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to Train-Case.
201
+ *
202
+ * @example
203
+ * ```ts
204
+ * dashToTrain('hello-world'); // 'Hello-World'
205
+ * dashToTrain({ 'first-name': 'John' }); // { 'First-Name': 'John' }
206
+ * ```
207
+ */
208
+ export declare function dashToTrain<T extends object | string>(input: T): Result<T, "DashToTrain">;
209
+ /**
210
+ * Converts a string, or the keys of an object/array (deeply), from dash-case to dot.case.
211
+ *
212
+ * @example
213
+ * ```ts
214
+ * dashToDot('hello-world'); // 'hello.world'
215
+ * dashToDot({ 'first-name': 'John' }); // { 'first.name': 'John' }
216
+ * ```
217
+ */
218
+ export declare function dashToDot<T extends object | string>(input: T): Result<T, "DashToDot">;
219
+ //#endregion
220
+ //#region src/pascalCase/pascalCase.d.ts
221
+ /**
222
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to camelCase.
223
+ *
224
+ * @example
225
+ * ```ts
226
+ * pascalToCamel('HelloWorld'); // 'helloWorld'
227
+ * pascalToCamel({ FirstName: 'John' }); // { firstName: 'John' }
228
+ * ```
229
+ */
230
+ export declare function pascalToCamel<T extends object | string>(input: T): Result<T, "PascalToCamel">;
231
+ /**
232
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to snake_case.
233
+ *
234
+ * @example
235
+ * ```ts
236
+ * pascalToSnake('HelloWorld'); // 'hello_world'
237
+ * pascalToSnake({ FirstName: 'John' }); // { first_name: 'John' }
238
+ * ```
239
+ */
240
+ export declare function pascalToSnake<T extends object | string>(input: T): Result<T, "PascalToSnake">;
241
+ /**
242
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to dash-case.
243
+ *
244
+ * @example
245
+ * ```ts
246
+ * pascalToDash('HelloWorld'); // 'hello-world'
247
+ * pascalToDash({ FirstName: 'John' }); // { 'first-name': 'John' }
248
+ * ```
249
+ */
250
+ export declare function pascalToDash<T extends object | string>(input: T): Result<T, "PascalToDash">;
251
+ /**
252
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER_SNAKE_CASE.
253
+ *
254
+ * @example
255
+ * ```ts
256
+ * pascalToUpperSnake('HelloWorld'); // 'HELLO_WORLD'
257
+ * pascalToUpperSnake({ FirstName: 'John' }); // { FIRST_NAME: 'John' }
258
+ * ```
259
+ */
260
+ export declare function pascalToUpperSnake<T extends object | string>(input: T): Result<T, "PascalToUpperSnake">;
261
+ /**
262
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to UPPER-DASH-CASE.
263
+ *
264
+ * @example
265
+ * ```ts
266
+ * pascalToUpperDash('HelloWorld'); // 'HELLO-WORLD'
267
+ * pascalToUpperDash({ FirstName: 'John' }); // { 'FIRST-NAME': 'John' }
268
+ * ```
269
+ */
270
+ export declare function pascalToUpperDash<T extends object | string>(input: T): Result<T, "PascalToUpperDash">;
271
+ /**
272
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to Train-Case.
273
+ *
274
+ * @example
275
+ * ```ts
276
+ * pascalToTrain('HelloWorld'); // 'Hello-World'
277
+ * pascalToTrain({ FirstName: 'John' }); // { 'First-Name': 'John' }
278
+ * ```
279
+ */
280
+ export declare function pascalToTrain<T extends object | string>(input: T): Result<T, "PascalToTrain">;
281
+ /**
282
+ * Converts a string, or the keys of an object/array (deeply), from PascalCase to dot.case.
283
+ *
284
+ * @example
285
+ * ```ts
286
+ * pascalToDot('HelloWorld'); // 'hello.world'
287
+ * pascalToDot({ FirstName: 'John' }); // { 'first.name': 'John' }
288
+ * ```
289
+ */
290
+ export declare function pascalToDot<T extends object | string>(input: T): Result<T, "PascalToDot">;
291
+ //#endregion
292
+ //#region src/snakeCase/snakeCase.d.ts
293
+ /**
294
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to camelCase.
295
+ *
296
+ * @example
297
+ * ```ts
298
+ * snakeToCamel('hello_world'); // 'helloWorld'
299
+ * snakeToCamel({ first_name: 'John' }); // { firstName: 'John' }
300
+ * ```
301
+ */
302
+ export declare function snakeToCamel<T extends object | string>(input: T): Result<T, "SnakeToCamel">;
303
+ /**
304
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to dash-case.
305
+ *
306
+ * @example
307
+ * ```ts
308
+ * snakeToDash('hello_world'); // 'hello-world'
309
+ * snakeToDash({ first_name: 'John' }); // { 'first-name': 'John' }
310
+ * ```
311
+ */
312
+ export declare function snakeToDash<T extends object | string>(input: T): Result<T, "SnakeToDash">;
313
+ /**
314
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to PascalCase.
315
+ *
316
+ * @example
317
+ * ```ts
318
+ * snakeToPascal('hello_world'); // 'HelloWorld'
319
+ * snakeToPascal({ first_name: 'John' }); // { FirstName: 'John' }
320
+ * ```
321
+ */
322
+ export declare function snakeToPascal<T extends object | string>(input: T): Result<T, "SnakeToPascal">;
323
+ /**
324
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER_SNAKE_CASE.
325
+ *
326
+ * @example
327
+ * ```ts
328
+ * snakeToUpperSnake('hello_world'); // 'HELLO_WORLD'
329
+ * snakeToUpperSnake({ first_name: 'John' }); // { FIRST_NAME: 'John' }
330
+ * ```
331
+ */
332
+ export declare function snakeToUpperSnake<T extends object | string>(input: T): Result<T, "SnakeToUpperSnake">;
333
+ /**
334
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to UPPER-DASH-CASE.
335
+ *
336
+ * @example
337
+ * ```ts
338
+ * snakeToUpperDash('hello_world'); // 'HELLO-WORLD'
339
+ * snakeToUpperDash({ first_name: 'John' }); // { 'FIRST-NAME': 'John' }
340
+ * ```
341
+ */
342
+ export declare function snakeToUpperDash<T extends object | string>(input: T): Result<T, "SnakeToUpperDash">;
343
+ /**
344
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to Train-Case.
345
+ *
346
+ * @example
347
+ * ```ts
348
+ * snakeToTrain('hello_world'); // 'Hello-World'
349
+ * snakeToTrain({ first_name: 'John' }); // { 'First-Name': 'John' }
350
+ * ```
351
+ */
352
+ export declare function snakeToTrain<T extends object | string>(input: T): Result<T, "SnakeToTrain">;
353
+ /**
354
+ * Converts a string, or the keys of an object/array (deeply), from snake_case to dot.case.
355
+ *
356
+ * @example
357
+ * ```ts
358
+ * snakeToDot('hello_world'); // 'hello.world'
359
+ * snakeToDot({ first_name: 'John' }); // { 'first.name': 'John' }
360
+ * ```
361
+ */
362
+ export declare function snakeToDot<T extends object | string>(input: T): Result<T, "SnakeToDot">;
363
+ //#endregion
364
+ //#region src/trainCase/trainCase.d.ts
365
+ /**
366
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to camelCase.
367
+ *
368
+ * @example
369
+ * ```ts
370
+ * trainToCamel('Hello-World'); // 'helloWorld'
371
+ * trainToCamel({ 'First-Name': 'John' }); // { firstName: 'John' }
372
+ * ```
373
+ */
374
+ export declare function trainToCamel<T extends object | string>(input: T): Result<T, "TrainToCamel">;
375
+ /**
376
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to PascalCase.
377
+ *
378
+ * @example
379
+ * ```ts
380
+ * trainToPascal('Hello-World'); // 'HelloWorld'
381
+ * trainToPascal({ 'First-Name': 'John' }); // { FirstName: 'John' }
382
+ * ```
383
+ */
384
+ export declare function trainToPascal<T extends object | string>(input: T): Result<T, "TrainToPascal">;
385
+ /**
386
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to snake_case.
387
+ *
388
+ * @example
389
+ * ```ts
390
+ * trainToSnake('Hello-World'); // 'hello_world'
391
+ * trainToSnake({ 'First-Name': 'John' }); // { first_name: 'John' }
392
+ * ```
393
+ */
394
+ export declare function trainToSnake<T extends object | string>(input: T): Result<T, "TrainToSnake">;
395
+ /**
396
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to dash-case.
397
+ *
398
+ * @example
399
+ * ```ts
400
+ * trainToDash('Hello-World'); // 'hello-world'
401
+ * trainToDash({ 'First-Name': 'John' }); // { 'first-name': 'John' }
402
+ * ```
403
+ */
404
+ export declare function trainToDash<T extends object | string>(input: T): Result<T, "TrainToDash">;
405
+ /**
406
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to UPPER_SNAKE_CASE.
407
+ *
408
+ * @example
409
+ * ```ts
410
+ * trainToUpperSnake('Hello-World'); // 'HELLO_WORLD'
411
+ * trainToUpperSnake({ 'First-Name': 'John' }); // { FIRST_NAME: 'John' }
412
+ * ```
413
+ */
414
+ export declare function trainToUpperSnake<T extends object | string>(input: T): Result<T, "TrainToUpperSnake">;
415
+ /**
416
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to UPPER-DASH-CASE.
417
+ *
418
+ * @example
419
+ * ```ts
420
+ * trainToUpperDash('Hello-World'); // 'HELLO-WORLD'
421
+ * trainToUpperDash({ 'First-Name': 'John' }); // { 'FIRST-NAME': 'John' }
422
+ * ```
423
+ */
424
+ export declare function trainToUpperDash<T extends object | string>(input: T): Result<T, "TrainToUpperDash">;
425
+ /**
426
+ * Converts a string, or the keys of an object/array (deeply), from Train-Case to dot.case.
427
+ *
428
+ * @example
429
+ * ```ts
430
+ * trainToDot('Hello-World'); // 'hello.world'
431
+ * trainToDot({ 'First-Name': 'John' }); // { 'first.name': 'John' }
432
+ * ```
433
+ */
434
+ export declare function trainToDot<T extends object | string>(input: T): Result<T, "TrainToDot">;
435
+ //#endregion
436
+ //#region src/dotCase/dotCase.d.ts
437
+ /**
438
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to camelCase.
439
+ *
440
+ * @example
441
+ * ```ts
442
+ * dotToCamel('hello.world'); // 'helloWorld'
443
+ * dotToCamel({ 'first.name': 'John' }); // { firstName: 'John' }
444
+ * ```
445
+ */
446
+ export declare function dotToCamel<T extends object | string>(input: T): Result<T, "DotToCamel">;
447
+ /**
448
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to PascalCase.
449
+ *
450
+ * @example
451
+ * ```ts
452
+ * dotToPascal('hello.world'); // 'HelloWorld'
453
+ * dotToPascal({ 'first.name': 'John' }); // { FirstName: 'John' }
454
+ * ```
455
+ */
456
+ export declare function dotToPascal<T extends object | string>(input: T): Result<T, "DotToPascal">;
457
+ /**
458
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to snake_case.
459
+ *
460
+ * @example
461
+ * ```ts
462
+ * dotToSnake('hello.world'); // 'hello_world'
463
+ * dotToSnake({ 'first.name': 'John' }); // { first_name: 'John' }
464
+ * ```
465
+ */
466
+ export declare function dotToSnake<T extends object | string>(input: T): Result<T, "DotToSnake">;
467
+ /**
468
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to dash-case.
469
+ *
470
+ * @example
471
+ * ```ts
472
+ * dotToDash('hello.world'); // 'hello-world'
473
+ * dotToDash({ 'first.name': 'John' }); // { 'first-name': 'John' }
474
+ * ```
475
+ */
476
+ export declare function dotToDash<T extends object | string>(input: T): Result<T, "DotToDash">;
477
+ /**
478
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to UPPER_SNAKE_CASE.
479
+ *
480
+ * @example
481
+ * ```ts
482
+ * dotToUpperSnake('hello.world'); // 'HELLO_WORLD'
483
+ * dotToUpperSnake({ 'first.name': 'John' }); // { FIRST_NAME: 'John' }
484
+ * ```
485
+ */
486
+ export declare function dotToUpperSnake<T extends object | string>(input: T): Result<T, "DotToUpperSnake">;
487
+ /**
488
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to UPPER-DASH-CASE.
489
+ *
490
+ * @example
491
+ * ```ts
492
+ * dotToUpperDash('hello.world'); // 'HELLO-WORLD'
493
+ * dotToUpperDash({ 'first.name': 'John' }); // { 'FIRST-NAME': 'John' }
494
+ * ```
495
+ */
496
+ export declare function dotToUpperDash<T extends object | string>(input: T): Result<T, "DotToUpperDash">;
497
+ /**
498
+ * Converts a string, or the keys of an object/array (deeply), from dot.case to Train-Case.
499
+ *
500
+ * @example
501
+ * ```ts
502
+ * dotToTrain('hello.world'); // 'Hello-World'
503
+ * dotToTrain({ 'first.name': 'John' }); // { 'First-Name': 'John' }
504
+ * ```
505
+ */
506
+ export declare function dotToTrain<T extends object | string>(input: T): Result<T, "DotToTrain">;
507
+ //#endregion
508
+ //#region src/upperDashCase/upperDashCase.d.ts
509
+ /**
510
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to camelCase.
511
+ *
512
+ * @example
513
+ * ```ts
514
+ * upperDashToCamel('HELLO-WORLD'); // 'helloWorld'
515
+ * upperDashToCamel({ 'FIRST-NAME': 'John' }); // { firstName: 'John' }
516
+ * ```
517
+ */
518
+ export declare function upperDashToCamel<T extends object | string>(input: T): Result<T, "UpperDashToCamel">;
519
+ /**
520
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to snake_case.
521
+ *
522
+ * @example
523
+ * ```ts
524
+ * upperDashToSnake('HELLO-WORLD'); // 'hello_world'
525
+ * upperDashToSnake({ 'FIRST-NAME': 'John' }); // { first_name: 'John' }
526
+ * ```
527
+ */
528
+ export declare function upperDashToSnake<T extends object | string>(input: T): Result<T, "UpperDashToSnake">;
529
+ /**
530
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to dash-case.
531
+ *
532
+ * @example
533
+ * ```ts
534
+ * upperDashToDash('HELLO-WORLD'); // 'hello-world'
535
+ * upperDashToDash({ 'FIRST-NAME': 'John' }); // { 'first-name': 'John' }
536
+ * ```
537
+ */
538
+ export declare function upperDashToDash<T extends object | string>(input: T): Result<T, "UpperDashToDash">;
539
+ /**
540
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to PascalCase.
541
+ *
542
+ * @example
543
+ * ```ts
544
+ * upperDashToPascal('HELLO-WORLD'); // 'HelloWorld'
545
+ * upperDashToPascal({ 'FIRST-NAME': 'John' }); // { FirstName: 'John' }
546
+ * ```
547
+ */
548
+ export declare function upperDashToPascal<T extends object | string>(input: T): Result<T, "UpperDashToPascal">;
549
+ /**
550
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to UPPER_SNAKE_CASE.
551
+ *
552
+ * @example
553
+ * ```ts
554
+ * upperDashToUpperSnake('HELLO-WORLD'); // 'HELLO_WORLD'
555
+ * upperDashToUpperSnake({ 'FIRST-NAME': 'John' }); // { FIRST_NAME: 'John' }
556
+ * ```
557
+ */
558
+ export declare function upperDashToUpperSnake<T extends object | string>(input: T): Result<T, "UpperDashToUpperSnake">;
559
+ /**
560
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to Train-Case.
561
+ *
562
+ * @example
563
+ * ```ts
564
+ * upperDashToTrain('HELLO-WORLD'); // 'Hello-World'
565
+ * upperDashToTrain({ 'FIRST-NAME': 'John' }); // { 'First-Name': 'John' }
566
+ * ```
567
+ */
568
+ export declare function upperDashToTrain<T extends object | string>(input: T): Result<T, "UpperDashToTrain">;
569
+ /**
570
+ * Converts a string, or the keys of an object/array (deeply), from UPPER-DASH-CASE to dot.case.
571
+ *
572
+ * @example
573
+ * ```ts
574
+ * upperDashToDot('HELLO-WORLD'); // 'hello.world'
575
+ * upperDashToDot({ 'FIRST-NAME': 'John' }); // { 'first.name': 'John' }
576
+ * ```
577
+ */
578
+ export declare function upperDashToDot<T extends object | string>(input: T): Result<T, "UpperDashToDot">;
579
+ //#endregion
580
+ //#region src/upperSnakeCase/upperSnakeCase.d.ts
581
+ /**
582
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to camelCase.
583
+ *
584
+ * @example
585
+ * ```ts
586
+ * upperSnakeToCamel('HELLO_WORLD'); // 'helloWorld'
587
+ * upperSnakeToCamel({ FIRST_NAME: 'John' }); // { firstName: 'John' }
588
+ * ```
589
+ */
590
+ export declare function upperSnakeToCamel<T extends object | string>(input: T): Result<T, "UpperSnakeToCamel">;
591
+ /**
592
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to snake_case.
593
+ *
594
+ * @example
595
+ * ```ts
596
+ * upperSnakeToSnake('HELLO_WORLD'); // 'hello_world'
597
+ * upperSnakeToSnake({ FIRST_NAME: 'John' }); // { first_name: 'John' }
598
+ * ```
599
+ */
600
+ export declare function upperSnakeToSnake<T extends object | string>(input: T): Result<T, "UpperSnakeToSnake">;
601
+ /**
602
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to dash-case.
603
+ *
604
+ * @example
605
+ * ```ts
606
+ * upperSnakeToDash('HELLO_WORLD'); // 'hello-world'
607
+ * upperSnakeToDash({ FIRST_NAME: 'John' }); // { 'first-name': 'John' }
608
+ * ```
609
+ */
610
+ export declare function upperSnakeToDash<T extends object | string>(input: T): Result<T, "UpperSnakeToDash">;
611
+ /**
612
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to PascalCase.
613
+ *
614
+ * @example
615
+ * ```ts
616
+ * upperSnakeToPascal('HELLO_WORLD'); // 'HelloWorld'
617
+ * upperSnakeToPascal({ FIRST_NAME: 'John' }); // { FirstName: 'John' }
618
+ * ```
619
+ */
620
+ export declare function upperSnakeToPascal<T extends object | string>(input: T): Result<T, "UpperSnakeToPascal">;
621
+ /**
622
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to UPPER-DASH-CASE.
623
+ *
624
+ * @example
625
+ * ```ts
626
+ * upperSnakeToUpperDash('HELLO_WORLD'); // 'HELLO-WORLD'
627
+ * upperSnakeToUpperDash({ FIRST_NAME: 'John' }); // { 'FIRST-NAME': 'John' }
628
+ * ```
629
+ */
630
+ export declare function upperSnakeToUpperDash<T extends object | string>(input: T): Result<T, "UpperSnakeToUpperDash">;
631
+ /**
632
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to Train-Case.
633
+ *
634
+ * @example
635
+ * ```ts
636
+ * upperSnakeToTrain('HELLO_WORLD'); // 'Hello-World'
637
+ * upperSnakeToTrain({ FIRST_NAME: 'John' }); // { 'First-Name': 'John' }
638
+ * ```
639
+ */
640
+ export declare function upperSnakeToTrain<T extends object | string>(input: T): Result<T, "UpperSnakeToTrain">;
641
+ /**
642
+ * Converts a string, or the keys of an object/array (deeply), from UPPER_SNAKE_CASE to dot.case.
643
+ *
644
+ * @example
645
+ * ```ts
646
+ * upperSnakeToDot('HELLO_WORLD'); // 'hello.world'
647
+ * upperSnakeToDot({ FIRST_NAME: 'John' }); // { 'first.name': 'John' }
648
+ * ```
649
+ */
650
+ export declare function upperSnakeToDot<T extends object | string>(input: T): Result<T, "UpperSnakeToDot">;
651
+ //#endregion
652
+ export type { ParserType, Prettify, Result };