UNPKG

32.3 kBTypeScriptView Raw
1import { Moment } from 'moment';
2export * from './shared';
3import { array, date, Enum, error, func, locale, number, object, url, search, string, validation, dataTypes, stream } from './shared';
4/***** Merge shared & Node error handling and export *****/
5import * as nodeError from './src/node/node-error';
6export * from './src/node/node-error';
7export { nodeError };
8export { error as errorShared } from './shared';
9declare const err: {
10 globalActivateCleanStack: () => void;
11 scrubStackTrace(stack: string, srcFn?: string): string;
12 removeFromStack(stack: string, libsToRm?: string[]): string;
13 getFirstStackItem(stack: string): string;
14 getFirstStackItem<T extends Error>(error: T): string;
15 getSecondStackItem(stack: string): string;
16 getSecondStackItem<T extends Error>(error: T): string;
17 getThirdStackItem(stack: string): string;
18 getThirdStackItem<T extends Error>(error: T): string;
19};
20export { err };
21export { err as error };
22/***** Export Node-specific modules/namespaces *****/
23import * as middleware from './src/node/middleware';
24export * from './src/node/middleware';
25export { middleware };
26export { middleware as middlewares };
27export { middleware as mware };
28export { middleware as MW };
29import * as test from './src/node/test';
30export * from './src/node/test';
31export { test };
32import * as file from './src/node/file';
33export * from './src/node/file';
34export { file };
35import * as expressRouting from './src/node/express-routing';
36export * from './src/node/express-routing';
37export { expressRouting };
38import * as typesIso from './src/types-iso';
39export * from './src/node/types-node';
40export declare const types: {
41 biologicalSexes: Readonly<{
42 male: "male";
43 female: "female";
44 }>;
45 commonBiologicalSexes: Readonly<{
46 male: "male";
47 female: "female";
48 }>;
49 sexes: Readonly<{
50 male: "male";
51 female: "female";
52 }>;
53 commonSexes: Readonly<{
54 male: "male";
55 female: "female";
56 }>;
57 biologicalSexesWithBoth: Readonly<Readonly<{
58 male: "male";
59 female: "female";
60 }> & {
61 both: "both";
62 }>;
63 commonBiologicalSexesWithBoth: Readonly<Readonly<{
64 male: "male";
65 female: "female";
66 }> & {
67 both: "both";
68 }>;
69 sexesWithBoth: Readonly<Readonly<{
70 male: "male";
71 female: "female";
72 }> & {
73 both: "both";
74 }>;
75 commonSexesWithBoth: Readonly<Readonly<{
76 male: "male";
77 female: "female";
78 }> & {
79 both: "both";
80 }>;
81 sexWithBoth: Readonly<Readonly<{
82 male: "male";
83 female: "female";
84 }> & {
85 both: "both";
86 }>;
87 biologicalSexesWithOther: Readonly<Readonly<{
88 male: "male";
89 female: "female";
90 }> & {
91 other: "other";
92 }>;
93 sexesWithOther: Readonly<Readonly<{
94 male: "male";
95 female: "female";
96 }> & {
97 other: "other";
98 }>;
99 commonSexesWithOther: Readonly<Readonly<{
100 male: "male";
101 female: "female";
102 }> & {
103 other: "other";
104 }>;
105 commonBiologicalSexesWithOther: Readonly<Readonly<{
106 male: "male";
107 female: "female";
108 }> & {
109 other: "other";
110 }>;
111 gender: Readonly<Readonly<{
112 male: "male";
113 female: "female";
114 }> & {
115 other: "other";
116 }>;
117 genderCommon: Readonly<Readonly<{
118 male: "male";
119 female: "female";
120 }> & {
121 other: "other";
122 }>;
123 genderWithBoth: Readonly<Readonly<{
124 male: "male";
125 female: "female";
126 }> & {
127 both: "both";
128 }>;
129 genderCommonWithBoth: Readonly<Readonly<{
130 male: "male";
131 female: "female";
132 }> & {
133 both: "both";
134 }>;
135 genderFull: Readonly<Readonly<Readonly<{
136 male: "male";
137 female: "female";
138 }> & {
139 other: "other";
140 }> & {
141 transMale: "trans male";
142 transFemale: "trans female";
143 genderqueer: "genderqueer";
144 genderfluid: "genderfluid";
145 intersex: "intersex";
146 agender: "agender";
147 bigender: "bigender";
148 nonBinary: "nonBinary";
149 none: "none";
150 }>;
151 CANProvinces: Readonly<{
152 on: "Ontario";
153 qc: "Quebec";
154 nb: "New Brunswick";
155 ns: "Nova Scotia";
156 pe: "Prince Edward Island";
157 mb: "Manitoba";
158 sk: "Saskatchewan";
159 bc: "British Columbia";
160 nt: "Northwest Territories";
161 nu: "Nunavut";
162 yt: "Yukon Territory";
163 ab: "Alberta";
164 nl: "Newfoundland and Labrador";
165 }>;
166 CANProvincesOrNone: Readonly<Readonly<{
167 on: "Ontario";
168 qc: "Quebec";
169 nb: "New Brunswick";
170 ns: "Nova Scotia";
171 pe: "Prince Edward Island";
172 mb: "Manitoba";
173 sk: "Saskatchewan";
174 bc: "British Columbia";
175 nt: "Northwest Territories";
176 nu: "Nunavut";
177 yt: "Yukon Territory";
178 ab: "Alberta";
179 nl: "Newfoundland and Labrador";
180 }> & {
181 none: "none";
182 }>;
183 canadianProvinces: Readonly<{
184 on: "Ontario";
185 qc: "Quebec";
186 nb: "New Brunswick";
187 ns: "Nova Scotia";
188 pe: "Prince Edward Island";
189 mb: "Manitoba";
190 sk: "Saskatchewan";
191 bc: "British Columbia";
192 nt: "Northwest Territories";
193 nu: "Nunavut";
194 yt: "Yukon Territory";
195 ab: "Alberta";
196 nl: "Newfoundland and Labrador";
197 }>;
198 canadianProvincesOrNone: Readonly<Readonly<{
199 on: "Ontario";
200 qc: "Quebec";
201 nb: "New Brunswick";
202 ns: "Nova Scotia";
203 pe: "Prince Edward Island";
204 mb: "Manitoba";
205 sk: "Saskatchewan";
206 bc: "British Columbia";
207 nt: "Northwest Territories";
208 nu: "Nunavut";
209 yt: "Yukon Territory";
210 ab: "Alberta";
211 nl: "Newfoundland and Labrador";
212 }> & {
213 none: "none";
214 }>;
215 isUndefined: (value: any) => value is undefined;
216 isNullOrUndefined: (val: any) => val is null;
217 isVoidOrString: (val: any) => val is string;
218 isAlphabeticChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
219 isAlphaChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
220 isNumber: <T extends number | Number = number>(val: any) => val is T;
221 isNum: <T extends number | Number = number>(val: any) => val is T;
222 isNumberLike: <T extends string | number | String | Number = number>(val: any) => val is T;
223 isNumLike: <T extends string | number | String | Number = number>(val: any) => val is T;
224 isInteger: <T extends string | number | String | Number = number>(val: any) => val is T;
225 isInt: <T extends string | number | String | Number = number>(val: any) => val is T;
226 isIntegerLike: <T extends string | number | String | Number = number>(val: any) => val is T;
227 isIntLike: <T extends string | number | String | Number = number>(val: any) => val is T;
228 isString: <T extends string | String = string>(val: any) => val is T;
229 isStringOrNumber: (val: any) => val is string | number | String | Number;
230 isStringOrNum: (val: any) => val is string | number | String | Number;
231 isStrOrNum: (val: any) => val is string | number | String | Number;
232 isBoolean: <T extends boolean | Boolean = boolean>(val: any) => val is T;
233 isBool: <T extends boolean | Boolean = boolean>(val: any) => val is T;
234 isDateLike: <T extends string | boolean | Object | Moment>(val: any) => val is T;
235 isArray: <T = any>(val: any) => val is T[];
236 isObject: <T extends Object = Object>(val: any, trueForArrays?: boolean) => val is T;
237 isTrue: <T extends string | true | String = true>(val: any, include1CharVal?: boolean) => val is T;
238 isFalse: <T extends string | false | String = false>(val: any, include1CharVal?: boolean) => val is T;
239 isFunction: <T extends Function = (...args: any[]) => any>(val: any) => val is T;
240 singleton: <T extends typesIso.ClassConstructor>(constructor: T) => typesIso.SingletonInterface<any> & T;
241 boolStringToBool: (val: string | boolean, strict?: boolean) => boolean;
242 toBoolFromBoolString: (val: string | boolean, strict?: boolean) => boolean;
243 getType: (val: any, extraArrayDetectCb?: (val: any) => boolean) => typesIso.DataTypesExpanded;
244} & typeof dataTypes;
245/********************************************* EXPORT *********************************************/
246/**
247 * Top-level mad-utils namespace, containing all child namespaces
248 * Includes all contents of shared module plus node-specific namespaces
249 */
250export declare const mUtils: {
251 expressRouting: typeof expressRouting;
252 file: typeof file;
253 middleware: typeof middleware;
254 nodeErr: typeof nodeError;
255 nodeError: typeof nodeError;
256 search: typeof search;
257 stream: typeof stream;
258 test: typeof test;
259 type: {
260 biologicalSexes: Readonly<{
261 male: "male";
262 female: "female";
263 }>;
264 commonBiologicalSexes: Readonly<{
265 male: "male";
266 female: "female";
267 }>;
268 sexes: Readonly<{
269 male: "male";
270 female: "female";
271 }>;
272 commonSexes: Readonly<{
273 male: "male";
274 female: "female";
275 }>;
276 biologicalSexesWithBoth: Readonly<Readonly<{
277 male: "male";
278 female: "female";
279 }> & {
280 both: "both";
281 }>;
282 commonBiologicalSexesWithBoth: Readonly<Readonly<{
283 male: "male";
284 female: "female";
285 }> & {
286 both: "both";
287 }>;
288 sexesWithBoth: Readonly<Readonly<{
289 male: "male";
290 female: "female";
291 }> & {
292 both: "both";
293 }>;
294 commonSexesWithBoth: Readonly<Readonly<{
295 male: "male";
296 female: "female";
297 }> & {
298 both: "both";
299 }>;
300 sexWithBoth: Readonly<Readonly<{
301 male: "male";
302 female: "female";
303 }> & {
304 both: "both";
305 }>;
306 biologicalSexesWithOther: Readonly<Readonly<{
307 male: "male";
308 female: "female";
309 }> & {
310 other: "other";
311 }>;
312 sexesWithOther: Readonly<Readonly<{
313 male: "male";
314 female: "female";
315 }> & {
316 other: "other";
317 }>;
318 commonSexesWithOther: Readonly<Readonly<{
319 male: "male";
320 female: "female";
321 }> & {
322 other: "other";
323 }>;
324 commonBiologicalSexesWithOther: Readonly<Readonly<{
325 male: "male";
326 female: "female";
327 }> & {
328 other: "other";
329 }>;
330 gender: Readonly<Readonly<{
331 male: "male";
332 female: "female";
333 }> & {
334 other: "other";
335 }>;
336 genderCommon: Readonly<Readonly<{
337 male: "male";
338 female: "female";
339 }> & {
340 other: "other";
341 }>;
342 genderWithBoth: Readonly<Readonly<{
343 male: "male";
344 female: "female";
345 }> & {
346 both: "both";
347 }>;
348 genderCommonWithBoth: Readonly<Readonly<{
349 male: "male";
350 female: "female";
351 }> & {
352 both: "both";
353 }>;
354 genderFull: Readonly<Readonly<Readonly<{
355 male: "male";
356 female: "female";
357 }> & {
358 other: "other";
359 }> & {
360 transMale: "trans male";
361 transFemale: "trans female";
362 genderqueer: "genderqueer";
363 genderfluid: "genderfluid";
364 intersex: "intersex";
365 agender: "agender";
366 bigender: "bigender";
367 nonBinary: "nonBinary";
368 none: "none";
369 }>;
370 CANProvinces: Readonly<{
371 on: "Ontario";
372 qc: "Quebec";
373 nb: "New Brunswick";
374 ns: "Nova Scotia";
375 pe: "Prince Edward Island";
376 mb: "Manitoba";
377 sk: "Saskatchewan";
378 bc: "British Columbia";
379 nt: "Northwest Territories";
380 nu: "Nunavut";
381 yt: "Yukon Territory";
382 ab: "Alberta";
383 nl: "Newfoundland and Labrador";
384 }>;
385 CANProvincesOrNone: Readonly<Readonly<{
386 on: "Ontario";
387 qc: "Quebec";
388 nb: "New Brunswick";
389 ns: "Nova Scotia";
390 pe: "Prince Edward Island";
391 mb: "Manitoba";
392 sk: "Saskatchewan";
393 bc: "British Columbia";
394 nt: "Northwest Territories";
395 nu: "Nunavut";
396 yt: "Yukon Territory";
397 ab: "Alberta";
398 nl: "Newfoundland and Labrador";
399 }> & {
400 none: "none";
401 }>;
402 canadianProvinces: Readonly<{
403 on: "Ontario";
404 qc: "Quebec";
405 nb: "New Brunswick";
406 ns: "Nova Scotia";
407 pe: "Prince Edward Island";
408 mb: "Manitoba";
409 sk: "Saskatchewan";
410 bc: "British Columbia";
411 nt: "Northwest Territories";
412 nu: "Nunavut";
413 yt: "Yukon Territory";
414 ab: "Alberta";
415 nl: "Newfoundland and Labrador";
416 }>;
417 canadianProvincesOrNone: Readonly<Readonly<{
418 on: "Ontario";
419 qc: "Quebec";
420 nb: "New Brunswick";
421 ns: "Nova Scotia";
422 pe: "Prince Edward Island";
423 mb: "Manitoba";
424 sk: "Saskatchewan";
425 bc: "British Columbia";
426 nt: "Northwest Territories";
427 nu: "Nunavut";
428 yt: "Yukon Territory";
429 ab: "Alberta";
430 nl: "Newfoundland and Labrador";
431 }> & {
432 none: "none";
433 }>;
434 isUndefined: (value: any) => value is undefined;
435 isNullOrUndefined: (val: any) => val is null;
436 isVoidOrString: (val: any) => val is string;
437 isAlphabeticChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
438 isAlphaChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
439 isNumber: <T extends number | Number = number>(val: any) => val is T;
440 isNum: <T extends number | Number = number>(val: any) => val is T;
441 isNumberLike: <T extends string | number | String | Number = number>(val: any) => val is T;
442 isNumLike: <T extends string | number | String | Number = number>(val: any) => val is T;
443 isInteger: <T extends string | number | String | Number = number>(val: any) => val is T;
444 isInt: <T extends string | number | String | Number = number>(val: any) => val is T;
445 isIntegerLike: <T extends string | number | String | Number = number>(val: any) => val is T;
446 isIntLike: <T extends string | number | String | Number = number>(val: any) => val is T;
447 isString: <T extends string | String = string>(val: any) => val is T;
448 isStringOrNumber: (val: any) => val is string | number | String | Number;
449 isStringOrNum: (val: any) => val is string | number | String | Number;
450 isStrOrNum: (val: any) => val is string | number | String | Number;
451 isBoolean: <T extends boolean | Boolean = boolean>(val: any) => val is T;
452 isBool: <T extends boolean | Boolean = boolean>(val: any) => val is T;
453 isDateLike: <T extends string | boolean | Object | Moment>(val: any) => val is T;
454 isArray: <T = any>(val: any) => val is T[];
455 isObject: <T extends Object = Object>(val: any, trueForArrays?: boolean) => val is T;
456 isTrue: <T extends string | true | String = true>(val: any, include1CharVal?: boolean) => val is T;
457 isFalse: <T extends string | false | String = false>(val: any, include1CharVal?: boolean) => val is T;
458 isFunction: <T extends Function = (...args: any[]) => any>(val: any) => val is T;
459 singleton: <T extends typesIso.ClassConstructor>(constructor: T) => typesIso.SingletonInterface<any> & T;
460 boolStringToBool: (val: string | boolean, strict?: boolean) => boolean;
461 toBoolFromBoolString: (val: string | boolean, strict?: boolean) => boolean;
462 getType: (val: any, extraArrayDetectCb?: (val: any) => boolean) => typesIso.DataTypesExpanded;
463 } & typeof dataTypes;
464 types: {
465 biologicalSexes: Readonly<{
466 male: "male";
467 female: "female";
468 }>;
469 commonBiologicalSexes: Readonly<{
470 male: "male";
471 female: "female";
472 }>;
473 sexes: Readonly<{
474 male: "male";
475 female: "female";
476 }>;
477 commonSexes: Readonly<{
478 male: "male";
479 female: "female";
480 }>;
481 biologicalSexesWithBoth: Readonly<Readonly<{
482 male: "male";
483 female: "female";
484 }> & {
485 both: "both";
486 }>;
487 commonBiologicalSexesWithBoth: Readonly<Readonly<{
488 male: "male";
489 female: "female";
490 }> & {
491 both: "both";
492 }>;
493 sexesWithBoth: Readonly<Readonly<{
494 male: "male";
495 female: "female";
496 }> & {
497 both: "both";
498 }>;
499 commonSexesWithBoth: Readonly<Readonly<{
500 male: "male";
501 female: "female";
502 }> & {
503 both: "both";
504 }>;
505 sexWithBoth: Readonly<Readonly<{
506 male: "male";
507 female: "female";
508 }> & {
509 both: "both";
510 }>;
511 biologicalSexesWithOther: Readonly<Readonly<{
512 male: "male";
513 female: "female";
514 }> & {
515 other: "other";
516 }>;
517 sexesWithOther: Readonly<Readonly<{
518 male: "male";
519 female: "female";
520 }> & {
521 other: "other";
522 }>;
523 commonSexesWithOther: Readonly<Readonly<{
524 male: "male";
525 female: "female";
526 }> & {
527 other: "other";
528 }>;
529 commonBiologicalSexesWithOther: Readonly<Readonly<{
530 male: "male";
531 female: "female";
532 }> & {
533 other: "other";
534 }>;
535 gender: Readonly<Readonly<{
536 male: "male";
537 female: "female";
538 }> & {
539 other: "other";
540 }>;
541 genderCommon: Readonly<Readonly<{
542 male: "male";
543 female: "female";
544 }> & {
545 other: "other";
546 }>;
547 genderWithBoth: Readonly<Readonly<{
548 male: "male";
549 female: "female";
550 }> & {
551 both: "both";
552 }>;
553 genderCommonWithBoth: Readonly<Readonly<{
554 male: "male";
555 female: "female";
556 }> & {
557 both: "both";
558 }>;
559 genderFull: Readonly<Readonly<Readonly<{
560 male: "male";
561 female: "female";
562 }> & {
563 other: "other";
564 }> & {
565 transMale: "trans male";
566 transFemale: "trans female";
567 genderqueer: "genderqueer";
568 genderfluid: "genderfluid";
569 intersex: "intersex";
570 agender: "agender";
571 bigender: "bigender";
572 nonBinary: "nonBinary";
573 none: "none";
574 }>;
575 CANProvinces: Readonly<{
576 on: "Ontario";
577 qc: "Quebec";
578 nb: "New Brunswick";
579 ns: "Nova Scotia";
580 pe: "Prince Edward Island";
581 mb: "Manitoba";
582 sk: "Saskatchewan";
583 bc: "British Columbia";
584 nt: "Northwest Territories";
585 nu: "Nunavut";
586 yt: "Yukon Territory";
587 ab: "Alberta";
588 nl: "Newfoundland and Labrador";
589 }>;
590 CANProvincesOrNone: Readonly<Readonly<{
591 on: "Ontario";
592 qc: "Quebec";
593 nb: "New Brunswick";
594 ns: "Nova Scotia";
595 pe: "Prince Edward Island";
596 mb: "Manitoba";
597 sk: "Saskatchewan";
598 bc: "British Columbia";
599 nt: "Northwest Territories";
600 nu: "Nunavut";
601 yt: "Yukon Territory";
602 ab: "Alberta";
603 nl: "Newfoundland and Labrador";
604 }> & {
605 none: "none";
606 }>;
607 canadianProvinces: Readonly<{
608 on: "Ontario";
609 qc: "Quebec";
610 nb: "New Brunswick";
611 ns: "Nova Scotia";
612 pe: "Prince Edward Island";
613 mb: "Manitoba";
614 sk: "Saskatchewan";
615 bc: "British Columbia";
616 nt: "Northwest Territories";
617 nu: "Nunavut";
618 yt: "Yukon Territory";
619 ab: "Alberta";
620 nl: "Newfoundland and Labrador";
621 }>;
622 canadianProvincesOrNone: Readonly<Readonly<{
623 on: "Ontario";
624 qc: "Quebec";
625 nb: "New Brunswick";
626 ns: "Nova Scotia";
627 pe: "Prince Edward Island";
628 mb: "Manitoba";
629 sk: "Saskatchewan";
630 bc: "British Columbia";
631 nt: "Northwest Territories";
632 nu: "Nunavut";
633 yt: "Yukon Territory";
634 ab: "Alberta";
635 nl: "Newfoundland and Labrador";
636 }> & {
637 none: "none";
638 }>;
639 isUndefined: (value: any) => value is undefined;
640 isNullOrUndefined: (val: any) => val is null;
641 isVoidOrString: (val: any) => val is string;
642 isAlphabeticChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
643 isAlphaChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
644 isNumber: <T extends number | Number = number>(val: any) => val is T;
645 isNum: <T extends number | Number = number>(val: any) => val is T;
646 isNumberLike: <T extends string | number | String | Number = number>(val: any) => val is T;
647 isNumLike: <T extends string | number | String | Number = number>(val: any) => val is T;
648 isInteger: <T extends string | number | String | Number = number>(val: any) => val is T;
649 isInt: <T extends string | number | String | Number = number>(val: any) => val is T;
650 isIntegerLike: <T extends string | number | String | Number = number>(val: any) => val is T;
651 isIntLike: <T extends string | number | String | Number = number>(val: any) => val is T;
652 isString: <T extends string | String = string>(val: any) => val is T;
653 isStringOrNumber: (val: any) => val is string | number | String | Number;
654 isStringOrNum: (val: any) => val is string | number | String | Number;
655 isStrOrNum: (val: any) => val is string | number | String | Number;
656 isBoolean: <T extends boolean | Boolean = boolean>(val: any) => val is T;
657 isBool: <T extends boolean | Boolean = boolean>(val: any) => val is T;
658 isDateLike: <T extends string | boolean | Object | Moment>(val: any) => val is T;
659 isArray: <T = any>(val: any) => val is T[];
660 isObject: <T extends Object = Object>(val: any, trueForArrays?: boolean) => val is T;
661 isTrue: <T extends string | true | String = true>(val: any, include1CharVal?: boolean) => val is T;
662 isFalse: <T extends string | false | String = false>(val: any, include1CharVal?: boolean) => val is T;
663 isFunction: <T extends Function = (...args: any[]) => any>(val: any) => val is T;
664 singleton: <T extends typesIso.ClassConstructor>(constructor: T) => typesIso.SingletonInterface<any> & T;
665 boolStringToBool: (val: string | boolean, strict?: boolean) => boolean;
666 toBoolFromBoolString: (val: string | boolean, strict?: boolean) => boolean;
667 getType: (val: any, extraArrayDetectCb?: (val: any) => boolean) => typesIso.DataTypesExpanded;
668 } & typeof dataTypes;
669 typing: {
670 biologicalSexes: Readonly<{
671 male: "male";
672 female: "female";
673 }>;
674 commonBiologicalSexes: Readonly<{
675 male: "male";
676 female: "female";
677 }>;
678 sexes: Readonly<{
679 male: "male";
680 female: "female";
681 }>;
682 commonSexes: Readonly<{
683 male: "male";
684 female: "female";
685 }>;
686 biologicalSexesWithBoth: Readonly<Readonly<{
687 male: "male";
688 female: "female";
689 }> & {
690 both: "both";
691 }>;
692 commonBiologicalSexesWithBoth: Readonly<Readonly<{
693 male: "male";
694 female: "female";
695 }> & {
696 both: "both";
697 }>;
698 sexesWithBoth: Readonly<Readonly<{
699 male: "male";
700 female: "female";
701 }> & {
702 both: "both";
703 }>;
704 commonSexesWithBoth: Readonly<Readonly<{
705 male: "male";
706 female: "female";
707 }> & {
708 both: "both";
709 }>;
710 sexWithBoth: Readonly<Readonly<{
711 male: "male";
712 female: "female";
713 }> & {
714 both: "both";
715 }>;
716 biologicalSexesWithOther: Readonly<Readonly<{
717 male: "male";
718 female: "female";
719 }> & {
720 other: "other";
721 }>;
722 sexesWithOther: Readonly<Readonly<{
723 male: "male";
724 female: "female";
725 }> & {
726 other: "other";
727 }>;
728 commonSexesWithOther: Readonly<Readonly<{
729 male: "male";
730 female: "female";
731 }> & {
732 other: "other";
733 }>;
734 commonBiologicalSexesWithOther: Readonly<Readonly<{
735 male: "male";
736 female: "female";
737 }> & {
738 other: "other";
739 }>;
740 gender: Readonly<Readonly<{
741 male: "male";
742 female: "female";
743 }> & {
744 other: "other";
745 }>;
746 genderCommon: Readonly<Readonly<{
747 male: "male";
748 female: "female";
749 }> & {
750 other: "other";
751 }>;
752 genderWithBoth: Readonly<Readonly<{
753 male: "male";
754 female: "female";
755 }> & {
756 both: "both";
757 }>;
758 genderCommonWithBoth: Readonly<Readonly<{
759 male: "male";
760 female: "female";
761 }> & {
762 both: "both";
763 }>;
764 genderFull: Readonly<Readonly<Readonly<{
765 male: "male";
766 female: "female";
767 }> & {
768 other: "other";
769 }> & {
770 transMale: "trans male";
771 transFemale: "trans female";
772 genderqueer: "genderqueer";
773 genderfluid: "genderfluid";
774 intersex: "intersex";
775 agender: "agender";
776 bigender: "bigender";
777 nonBinary: "nonBinary";
778 none: "none";
779 }>;
780 CANProvinces: Readonly<{
781 on: "Ontario";
782 qc: "Quebec";
783 nb: "New Brunswick";
784 ns: "Nova Scotia";
785 pe: "Prince Edward Island";
786 mb: "Manitoba";
787 sk: "Saskatchewan";
788 bc: "British Columbia";
789 nt: "Northwest Territories";
790 nu: "Nunavut";
791 yt: "Yukon Territory";
792 ab: "Alberta";
793 nl: "Newfoundland and Labrador";
794 }>;
795 CANProvincesOrNone: Readonly<Readonly<{
796 on: "Ontario";
797 qc: "Quebec";
798 nb: "New Brunswick";
799 ns: "Nova Scotia";
800 pe: "Prince Edward Island";
801 mb: "Manitoba";
802 sk: "Saskatchewan";
803 bc: "British Columbia";
804 nt: "Northwest Territories";
805 nu: "Nunavut";
806 yt: "Yukon Territory";
807 ab: "Alberta";
808 nl: "Newfoundland and Labrador";
809 }> & {
810 none: "none";
811 }>;
812 canadianProvinces: Readonly<{
813 on: "Ontario";
814 qc: "Quebec";
815 nb: "New Brunswick";
816 ns: "Nova Scotia";
817 pe: "Prince Edward Island";
818 mb: "Manitoba";
819 sk: "Saskatchewan";
820 bc: "British Columbia";
821 nt: "Northwest Territories";
822 nu: "Nunavut";
823 yt: "Yukon Territory";
824 ab: "Alberta";
825 nl: "Newfoundland and Labrador";
826 }>;
827 canadianProvincesOrNone: Readonly<Readonly<{
828 on: "Ontario";
829 qc: "Quebec";
830 nb: "New Brunswick";
831 ns: "Nova Scotia";
832 pe: "Prince Edward Island";
833 mb: "Manitoba";
834 sk: "Saskatchewan";
835 bc: "British Columbia";
836 nt: "Northwest Territories";
837 nu: "Nunavut";
838 yt: "Yukon Territory";
839 ab: "Alberta";
840 nl: "Newfoundland and Labrador";
841 }> & {
842 none: "none";
843 }>;
844 isUndefined: (value: any) => value is undefined;
845 isNullOrUndefined: (val: any) => val is null;
846 isVoidOrString: (val: any) => val is string;
847 isAlphabeticChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
848 isAlphaChar: <T extends string = string>(val: any, handleAccents?: boolean) => val is T;
849 isNumber: <T extends number | Number = number>(val: any) => val is T;
850 isNum: <T extends number | Number = number>(val: any) => val is T;
851 isNumberLike: <T extends string | number | String | Number = number>(val: any) => val is T;
852 isNumLike: <T extends string | number | String | Number = number>(val: any) => val is T;
853 isInteger: <T extends string | number | String | Number = number>(val: any) => val is T;
854 isInt: <T extends string | number | String | Number = number>(val: any) => val is T;
855 isIntegerLike: <T extends string | number | String | Number = number>(val: any) => val is T;
856 isIntLike: <T extends string | number | String | Number = number>(val: any) => val is T;
857 isString: <T extends string | String = string>(val: any) => val is T;
858 isStringOrNumber: (val: any) => val is string | number | String | Number;
859 isStringOrNum: (val: any) => val is string | number | String | Number;
860 isStrOrNum: (val: any) => val is string | number | String | Number;
861 isBoolean: <T extends boolean | Boolean = boolean>(val: any) => val is T;
862 isBool: <T extends boolean | Boolean = boolean>(val: any) => val is T;
863 isDateLike: <T extends string | boolean | Object | Moment>(val: any) => val is T;
864 isArray: <T = any>(val: any) => val is T[];
865 isObject: <T extends Object = Object>(val: any, trueForArrays?: boolean) => val is T;
866 isTrue: <T extends string | true | String = true>(val: any, include1CharVal?: boolean) => val is T;
867 isFalse: <T extends string | false | String = false>(val: any, include1CharVal?: boolean) => val is T;
868 isFunction: <T extends Function = (...args: any[]) => any>(val: any) => val is T;
869 singleton: <T extends typesIso.ClassConstructor>(constructor: T) => typesIso.SingletonInterface<any> & T;
870 boolStringToBool: (val: string | boolean, strict?: boolean) => boolean;
871 toBoolFromBoolString: (val: string | boolean, strict?: boolean) => boolean;
872 getType: (val: any, extraArrayDetectCb?: (val: any) => boolean) => typesIso.DataTypesExpanded;
873 } & typeof dataTypes;
874 array: typeof array;
875 /**
876 * Top-level mad-utils namespace, containing all child namespaces
877 * Includes all contents of shared module plus node-specific namespaces
878 */
879 date: typeof date;
880 commonDataTypes: typeof dataTypes;
881 dataTypes: typeof dataTypes;
882 enum: typeof Enum;
883 Enum: typeof Enum;
884 err: typeof error;
885 error: typeof error;
886 find: typeof search;
887 func: typeof func;
888 function: typeof func;
889 functionUtils: typeof func;
890 genericDataTypes: typeof dataTypes;
891 isNode: any;
892 locale: typeof locale;
893 math: typeof number;
894 num: typeof number;
895 number: typeof number;
896 numeric: typeof number;
897 object: typeof object;
898 url: typeof url;
899 srch: typeof search;
900 stacktrace: typeof error;
901 str: typeof string;
902 string: typeof string;
903 validation: typeof validation;
904};
905export { mUtils as __ };
906export { mUtils as m_ };
907export { mUtils as madUtils };