caseparser 2.1.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,46 +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 const _default: {
41
- upperSnakeToCamel<T extends string | object>(input: T): Result<T, "UpperSnakeToCamel">;
42
- upperSnakeToSnake<T_1 extends string | object>(input: T_1): Result<T_1, "UpperSnakeToSnake">;
43
- upperSnakeToDash<T_2 extends string | object>(input: T_2): Result<T_2, "UpperSnakeToDash">;
44
- upperSnakeToPascal<T_3 extends string | object>(input: T_3): Result<T_3, "UpperSnakeToPascal">;
45
- upperSnakeToUpperDash<T_4 extends string | object>(input: T_4): Result<T_4, "UpperSnakeToUpperDash">;
46
- upperDashToCamel<T_5 extends string | object>(input: T_5): Result<T_5, "UpperDashToCamel">;
47
- upperDashToSnake<T_6 extends string | object>(input: T_6): Result<T_6, "UpperDashToSnake">;
48
- upperDashToDash<T_7 extends string | object>(input: T_7): Result<T_7, "UpperDashToDash">;
49
- upperDashToPascal<T_8 extends string | object>(input: T_8): Result<T_8, "UpperDashToPascal">;
50
- upperDashToUpperSnake<T_9 extends string | object>(input: T_9): Result<T_9, "UpperDashToUpperSnake">;
51
- snakeToCamel<T_10 extends string | object>(input: T_10): Result<T_10, "SnakeToCamel">;
52
- snakeToDash<T_11 extends string | object>(input: T_11): Result<T_11, "SnakeToDash">;
53
- snakeToPascal<T_12 extends string | object>(input: T_12): Result<T_12, "SnakeToPascal">;
54
- snakeToUpperSnake<T_13 extends string | object>(input: T_13): Result<T_13, "SnakeToUpperSnake">;
55
- snakeToUpperDash<T_14 extends string | object>(input: T_14): Result<T_14, "SnakeToUpperDash">;
56
- pascalToCamel<T_15 extends string | object>(input: T_15): Result<T_15, "PascalToCamel">;
57
- pascalToSnake<T_16 extends string | object>(input: T_16): Result<T_16, "PascalToSnake">;
58
- pascalToDash<T_17 extends string | object>(input: T_17): Result<T_17, "PascalToDash">;
59
- pascalToUpperSnake<T_18 extends string | object>(input: T_18): Result<T_18, "PascalToUpperSnake">;
60
- pascalToUpperDash<T_19 extends string | object>(input: T_19): Result<T_19, "PascalToUpperDash">;
61
- dashToSnake<T_20 extends string | object>(input: T_20): Result<T_20, "DashToSnake">;
62
- dashToCamel<T_21 extends string | object>(input: T_21): Result<T_21, "DashToCamel">;
63
- dashToPascal<T_22 extends string | object>(input: T_22): Result<T_22, "DashToPascal">;
64
- dashToUpperSnake<T_23 extends string | object>(input: T_23): Result<T_23, "DashToUpperSnake">;
65
- dashToUpperDash<T_24 extends string | object>(input: T_24): Result<T_24, "DashToUpperDash">;
66
- camelToDash<T_25 extends string | object>(input: T_25): Result<T_25, "CamelToDash">;
67
- camelToSnake<T_26 extends string | object>(input: T_26): Result<T_26, "CamelToSnake">;
68
- camelToPascal<T_27 extends string | object>(input: T_27): Result<T_27, "CamelToPascal">;
69
- camelToUpperSnake<T_28 extends string | object>(input: T_28): Result<T_28, "CamelToUpperSnake">;
70
- camelToUpperDash<T_29 extends string | object>(input: T_29): Result<T_29, "CamelToUpperDash">;
71
- };
72
-
73
- export { _default as default };
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 };