UNPKG

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