caseparser 4.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.
package/dist/index.d.ts CHANGED
@@ -4,46 +4,74 @@ type CamelToPascal<T extends string> = Capitalize<T>;
4
4
  type CamelToSnake<T extends string> = T extends `${infer L}${infer R}` ? `${L extends Capitalize<L> ? "_" : ""}${Lowercase<L>}${CamelToSnake<R>}` : T;
5
5
  type CamelToUpperDash<T extends string> = Uppercase<CamelToDash<T>>;
6
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>>;
7
9
  type DashToCamel<T extends string> = T extends `${infer L}-${infer R}` ? `${L}${Capitalize<DashToCamel<R>>}` : T;
8
10
  type DashToPascal<T extends string> = Capitalize<DashToCamel<T>>;
9
11
  type DashToSnake<T extends string> = T extends `${infer L}-${infer R}` ? `${L}_${DashToSnake<R>}` : T;
10
12
  type DashToUpperDash<T extends string> = Uppercase<T>;
11
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;
12
16
  type PascalToCamel<T extends string> = Uncapitalize<T>;
13
17
  type PascalToDash<T extends string> = CamelToDash<Uncapitalize<T>>;
14
18
  type PascalToSnake<T extends string> = CamelToSnake<Uncapitalize<T>>;
15
19
  type PascalToUpperDash<T extends string> = Uppercase<PascalToDash<T>>;
16
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>>;
17
23
  type SnakeToCamel<T extends string> = T extends `${infer L}_${infer R}` ? `${L}${Capitalize<SnakeToCamel<R>>}` : T;
18
24
  type SnakeToDash<T extends string> = T extends `${infer L}_${infer R}` ? `${L}-${SnakeToDash<R>}` : T;
19
25
  type SnakeToPascal<T extends string> = Capitalize<SnakeToCamel<T>>;
20
26
  type SnakeToUpperDash<T extends string> = Uppercase<SnakeToDash<T>>;
21
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>>;
22
30
  type UpperDashToCamel<T extends string> = DashToCamel<Lowercase<T>>;
23
31
  type UpperDashToDash<T extends string> = Lowercase<T>;
24
32
  type UpperDashToPascal<T extends string> = Capitalize<UpperDashToCamel<T>>;
25
33
  type UpperDashToSnake<T extends string> = DashToSnake<UpperDashToDash<T>>;
26
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>>;
27
37
  type UpperSnakeToCamel<T extends string> = SnakeToCamel<Lowercase<T>>;
28
38
  type UpperSnakeToDash<T extends string> = SnakeToDash<Lowercase<T>>;
29
39
  type UpperSnakeToPascal<T extends string> = SnakeToPascal<Lowercase<T>>;
30
40
  type UpperSnakeToSnake<T extends string> = Lowercase<T>;
31
41
  type UpperSnakeToUpperDash<T extends string> = Uppercase<UpperSnakeToDash<T>>;
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";
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";
38
66
  /** Identifies a conversion, e.g. `'CamelToSnake'`. */
39
- type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType;
67
+ type ParserType = ParserCamelType | ParserDashType | ParserPascalType | ParserSnakeType | ParserUpperDashType | ParserUpperSnakeType | ParserTrainType | ParserDotType;
40
68
  /** Flattens an intersection/mapped type so editors show the resulting keys. */
41
69
  type Prettify<T> = { [K in keyof T]: T[K]; } & {};
42
70
  /**
43
71
  * The type returned by a conversion: strings stay `string`, and object keys
44
72
  * (deeply, including inside arrays) are renamed according to the conversion `P`.
45
73
  */
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;
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;
47
75
  //#endregion
48
76
  //#region src/camelCase/camelCase.d.ts
49
77
  /**
@@ -96,6 +124,26 @@ export declare function camelToUpperSnake<T extends object | string>(input: T):
96
124
  * ```
97
125
  */
98
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">;
99
147
  //#endregion
100
148
  //#region src/dashCase/dashCase.d.ts
101
149
  /**
@@ -148,6 +196,26 @@ export declare function dashToUpperSnake<T extends object | string>(input: T): R
148
196
  * ```
149
197
  */
150
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">;
151
219
  //#endregion
152
220
  //#region src/pascalCase/pascalCase.d.ts
153
221
  /**
@@ -200,6 +268,26 @@ export declare function pascalToUpperSnake<T extends object | string>(input: T):
200
268
  * ```
201
269
  */
202
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">;
203
291
  //#endregion
204
292
  //#region src/snakeCase/snakeCase.d.ts
205
293
  /**
@@ -252,6 +340,170 @@ export declare function snakeToUpperSnake<T extends object | string>(input: T):
252
340
  * ```
253
341
  */
254
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">;
255
507
  //#endregion
256
508
  //#region src/upperDashCase/upperDashCase.d.ts
257
509
  /**
@@ -304,6 +556,26 @@ export declare function upperDashToPascal<T extends object | string>(input: T):
304
556
  * ```
305
557
  */
306
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">;
307
579
  //#endregion
308
580
  //#region src/upperSnakeCase/upperSnakeCase.d.ts
309
581
  /**
@@ -356,5 +628,25 @@ export declare function upperSnakeToPascal<T extends object | string>(input: T):
356
628
  * ```
357
629
  */
358
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">;
359
651
  //#endregion
360
652
  export type { ParserType, Prettify, Result };