@types/lodash 4.14.150 → 4.14.154

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.
Files changed (7) hide show
  1. lodash/README.md +1 -1
  2. lodash/common/array.d.ts +1 -1
  3. lodash/common/common.d.ts +8 -0
  4. lodash/fp.d.ts +223 -220
  5. lodash/multiply.d.ts +1 -1
  6. lodash/package.json +3 -3
  7. lodash/ts3.1/common/array.d.ts +1 -1
lodash/fp.d.ts CHANGED
@@ -8,21 +8,24 @@ export = _;
8
8
 
9
9
  declare const _: _.LoDashFp;
10
10
  declare namespace _ {
11
- interface LodashAdd {
11
+ interface LodashConvertible {
12
+ convert(options: lodash.ConvertOptions): (...args: any[]) => any;
13
+ }
14
+ interface LodashAdd extends LodashConvertible {
12
15
  (augend: number): LodashAdd1x1;
13
16
  (augend: lodash.__, addend: number): LodashAdd1x2;
14
17
  (augend: number, addend: number): number;
15
18
  }
16
19
  type LodashAdd1x1 = (addend: number) => number;
17
20
  type LodashAdd1x2 = (augend: number) => number;
18
- interface LodashAfter {
21
+ interface LodashAfter extends LodashConvertible {
19
22
  <TFunc extends (...args: any[]) => any>(func: TFunc): LodashAfter1x1<TFunc>;
20
23
  (func: lodash.__, n: number): LodashAfter1x2;
21
24
  <TFunc extends (...args: any[]) => any>(func: TFunc, n: number): TFunc;
22
25
  }
23
26
  type LodashAfter1x1<TFunc> = (n: number) => TFunc;
24
27
  type LodashAfter1x2 = <TFunc extends (...args: any[]) => any>(func: TFunc) => TFunc;
25
- interface LodashEvery {
28
+ interface LodashEvery extends LodashConvertible {
26
29
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashEvery1x1<T>;
27
30
  <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashEvery1x2<T>;
28
31
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, collection: lodash.List<T> | null | undefined): boolean;
@@ -34,7 +37,7 @@ declare namespace _ {
34
37
  type LodashEvery2x2<T> = (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>) => boolean;
35
38
  type LodashOverEvery = <T>(predicates: lodash.Many<(...args: T[]) => boolean>) => (...args: T[]) => boolean;
36
39
  type LodashConstant = <T>(value: T) => () => T;
37
- interface LodashSome {
40
+ interface LodashSome extends LodashConvertible {
38
41
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashSome1x1<T>;
39
42
  <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashSome1x2<T>;
40
43
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, collection: lodash.List<T> | null | undefined): boolean;
@@ -46,21 +49,21 @@ declare namespace _ {
46
49
  type LodashSome2x2<T> = (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>) => boolean;
47
50
  type LodashOverSome = <T>(predicates: lodash.Many<(...args: T[]) => boolean>) => (...args: T[]) => boolean;
48
51
  type LodashApply = <TResult>(func: (...args: any[]) => TResult) => (...args: any[]) => TResult;
49
- interface LodashAry {
52
+ interface LodashAry extends LodashConvertible {
50
53
  (n: number): LodashAry1x1;
51
54
  (n: lodash.__, func: (...args: any[]) => any): LodashAry1x2;
52
55
  (n: number, func: (...args: any[]) => any): (...args: any[]) => any;
53
56
  }
54
57
  type LodashAry1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any;
55
58
  type LodashAry1x2 = (n: number) => (...args: any[]) => any;
56
- interface LodashAssign {
59
+ interface LodashAssign extends LodashConvertible {
57
60
  <TObject>(object: TObject): LodashAssign1x1<TObject>;
58
61
  <TSource>(object: lodash.__, source: TSource): LodashAssign1x2<TSource>;
59
62
  <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
60
63
  }
61
64
  type LodashAssign1x1<TObject> = <TSource>(source: TSource) => TObject & TSource;
62
65
  type LodashAssign1x2<TSource> = <TObject>(object: TObject) => TObject & TSource;
63
- interface LodashAssignAll {
66
+ interface LodashAssignAll extends LodashConvertible {
64
67
  <TObject, TSource>(object: [TObject, TSource]): TObject & TSource;
65
68
  <TObject, TSource1, TSource2>(object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2;
66
69
  <TObject, TSource1, TSource2, TSource3>(object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3;
@@ -68,21 +71,21 @@ declare namespace _ {
68
71
  <TObject>(object: [TObject]): TObject;
69
72
  (object: ReadonlyArray<any>): any;
70
73
  }
71
- interface LodashAssignAllWith {
74
+ interface LodashAssignAllWith extends LodashConvertible {
72
75
  (customizer: lodash.AssignCustomizer): LodashAssignAllWith1x1;
73
76
  (customizer: lodash.__, args: ReadonlyArray<any>): LodashAssignAllWith1x2;
74
77
  (customizer: lodash.AssignCustomizer, args: ReadonlyArray<any>): any;
75
78
  }
76
79
  type LodashAssignAllWith1x1 = (args: ReadonlyArray<any>) => any;
77
80
  type LodashAssignAllWith1x2 = (customizer: lodash.AssignCustomizer) => any;
78
- interface LodashAssignIn {
81
+ interface LodashAssignIn extends LodashConvertible {
79
82
  <TObject>(object: TObject): LodashAssignIn1x1<TObject>;
80
83
  <TSource>(object: lodash.__, source: TSource): LodashAssignIn1x2<TSource>;
81
84
  <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
82
85
  }
83
86
  type LodashAssignIn1x1<TObject> = <TSource>(source: TSource) => TObject & TSource;
84
87
  type LodashAssignIn1x2<TSource> = <TObject>(object: TObject) => TObject & TSource;
85
- interface LodashAssignInAll {
88
+ interface LodashAssignInAll extends LodashConvertible {
86
89
  <TObject, TSource>(object: [TObject, TSource]): TObject & TSource;
87
90
  <TObject, TSource1, TSource2>(object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2;
88
91
  <TObject, TSource1, TSource2, TSource3>(object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3;
@@ -90,14 +93,14 @@ declare namespace _ {
90
93
  <TObject>(object: [TObject]): TObject;
91
94
  <TResult>(object: ReadonlyArray<any>): TResult;
92
95
  }
93
- interface LodashAssignInAllWith {
96
+ interface LodashAssignInAllWith extends LodashConvertible {
94
97
  (customizer: lodash.AssignCustomizer): LodashAssignInAllWith1x1;
95
98
  (customizer: lodash.__, args: ReadonlyArray<any>): LodashAssignInAllWith1x2;
96
99
  (customizer: lodash.AssignCustomizer, args: ReadonlyArray<any>): any;
97
100
  }
98
101
  type LodashAssignInAllWith1x1 = (args: ReadonlyArray<any>) => any;
99
102
  type LodashAssignInAllWith1x2 = (customizer: lodash.AssignCustomizer) => any;
100
- interface LodashAssignInWith {
103
+ interface LodashAssignInWith extends LodashConvertible {
101
104
  (customizer: lodash.AssignCustomizer): LodashAssignInWith1x1;
102
105
  <TObject>(customizer: lodash.__, object: TObject): LodashAssignInWith1x2<TObject>;
103
106
  <TObject>(customizer: lodash.AssignCustomizer, object: TObject): LodashAssignInWith1x3<TObject>;
@@ -124,7 +127,7 @@ declare namespace _ {
124
127
  }
125
128
  type LodashAssignInWith1x5<TSource> = <TObject>(object: TObject) => TObject & TSource;
126
129
  type LodashAssignInWith1x6<TObject, TSource> = (customizer: lodash.AssignCustomizer) => TObject & TSource;
127
- interface LodashAssignWith {
130
+ interface LodashAssignWith extends LodashConvertible {
128
131
  (customizer: lodash.AssignCustomizer): LodashAssignWith1x1;
129
132
  <TObject>(customizer: lodash.__, object: TObject): LodashAssignWith1x2<TObject>;
130
133
  <TObject>(customizer: lodash.AssignCustomizer, object: TObject): LodashAssignWith1x3<TObject>;
@@ -151,7 +154,7 @@ declare namespace _ {
151
154
  }
152
155
  type LodashAssignWith1x5<TSource> = <TObject>(object: TObject) => TObject & TSource;
153
156
  type LodashAssignWith1x6<TObject, TSource> = (customizer: lodash.AssignCustomizer) => TObject & TSource;
154
- interface LodashSet {
157
+ interface LodashSet extends LodashConvertible {
155
158
  (path: lodash.PropertyPath): LodashSet1x1;
156
159
  (path: lodash.__, value: any): LodashSet1x2;
157
160
  (path: lodash.PropertyPath, value: any): LodashSet1x3;
@@ -196,7 +199,7 @@ declare namespace _ {
196
199
  }
197
200
  type LodashSet2x5 = <TResult>(value: any) => TResult;
198
201
  type LodashSet2x6 = <TResult>(path: lodash.PropertyPath) => TResult;
199
- interface LodashAt {
202
+ interface LodashAt extends LodashConvertible {
200
203
  (props: lodash.PropertyPath): LodashAt1x1;
201
204
  <T>(props: lodash.__, object: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashAt1x2<T>;
202
205
  <T>(props: lodash.PropertyPath, object: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T[];
@@ -209,14 +212,14 @@ declare namespace _ {
209
212
  type LodashAt2x1<T> = (object: T | null | undefined) => Array<T[keyof T]>;
210
213
  type LodashAt2x2<T> = (props: lodash.Many<keyof T>) => Array<T[keyof T]>;
211
214
  type LodashAttempt = <TResult>(func: (...args: any[]) => TResult) => TResult|Error;
212
- interface LodashBefore {
215
+ interface LodashBefore extends LodashConvertible {
213
216
  <TFunc extends (...args: any[]) => any>(func: TFunc): LodashBefore1x1<TFunc>;
214
217
  (func: lodash.__, n: number): LodashBefore1x2;
215
218
  <TFunc extends (...args: any[]) => any>(func: TFunc, n: number): TFunc;
216
219
  }
217
220
  type LodashBefore1x1<TFunc> = (n: number) => TFunc;
218
221
  type LodashBefore1x2 = <TFunc extends (...args: any[]) => any>(func: TFunc) => TFunc;
219
- interface LodashBind {
222
+ interface LodashBind extends LodashConvertible {
220
223
  (func: (...args: any[]) => any): LodashBind1x1;
221
224
  (func: lodash.__, thisArg: any): LodashBind1x2;
222
225
  (func: (...args: any[]) => any, thisArg: any): (...args: any[]) => any;
@@ -224,14 +227,14 @@ declare namespace _ {
224
227
  }
225
228
  type LodashBind1x1 = (thisArg: any) => (...args: any[]) => any;
226
229
  type LodashBind1x2 = (func: (...args: any[]) => any) => (...args: any[]) => any;
227
- interface LodashBindAll {
230
+ interface LodashBindAll extends LodashConvertible {
228
231
  (methodNames: lodash.Many<string>): LodashBindAll1x1;
229
232
  <T>(methodNames: lodash.__, object: T): LodashBindAll1x2<T>;
230
233
  <T>(methodNames: lodash.Many<string>, object: T): T;
231
234
  }
232
235
  type LodashBindAll1x1 = <T>(object: T) => T;
233
236
  type LodashBindAll1x2<T> = (methodNames: lodash.Many<string>) => T;
234
- interface LodashBindKey {
237
+ interface LodashBindKey extends LodashConvertible {
235
238
  (object: object): LodashBindKey1x1;
236
239
  (object: lodash.__, key: string): LodashBindKey1x2;
237
240
  (object: object, key: string): (...args: any[]) => any;
@@ -243,14 +246,14 @@ declare namespace _ {
243
246
  type LodashCapitalize = (string: string) => string;
244
247
  type LodashCastArray = <T>(value: lodash.Many<T>) => T[];
245
248
  type LodashCeil = (n: number) => number;
246
- interface LodashChunk {
249
+ interface LodashChunk extends LodashConvertible {
247
250
  (size: number): LodashChunk1x1;
248
251
  <T>(size: lodash.__, array: lodash.List<T> | null | undefined): LodashChunk1x2<T>;
249
252
  <T>(size: number, array: lodash.List<T> | null | undefined): T[][];
250
253
  }
251
254
  type LodashChunk1x1 = <T>(array: lodash.List<T> | null | undefined) => T[][];
252
255
  type LodashChunk1x2<T> = (size: number) => T[][];
253
- interface LodashClamp {
256
+ interface LodashClamp extends LodashConvertible {
254
257
  (lower: number): LodashClamp1x1;
255
258
  (lower: lodash.__, upper: number): LodashClamp1x2;
256
259
  (lower: number, upper: number): LodashClamp1x3;
@@ -279,14 +282,14 @@ declare namespace _ {
279
282
  type LodashClamp1x6 = (lower: number) => number;
280
283
  type LodashClone = <T>(value: T) => T;
281
284
  type LodashCloneDeep = <T>(value: T) => T;
282
- interface LodashCloneDeepWith {
285
+ interface LodashCloneDeepWith extends LodashConvertible {
283
286
  <T>(customizer: lodash.CloneDeepWithCustomizer<T>): LodashCloneDeepWith1x1<T>;
284
287
  <T>(customizer: lodash.__, value: T): LodashCloneDeepWith1x2<T>;
285
288
  <T>(customizer: lodash.CloneDeepWithCustomizer<T>, value: T): any;
286
289
  }
287
290
  type LodashCloneDeepWith1x1<T> = (value: T) => any;
288
291
  type LodashCloneDeepWith1x2<T> = (customizer: lodash.CloneDeepWithCustomizer<T>) => any;
289
- interface LodashCloneWith {
292
+ interface LodashCloneWith extends LodashConvertible {
290
293
  <T, TResult extends object | string | number | boolean | null>(customizer: lodash.CloneWithCustomizer<T, TResult>): LodashCloneWith1x1<T, TResult>;
291
294
  <T>(customizer: lodash.__, value: T): LodashCloneWith1x2<T>;
292
295
  <T, TResult extends object | string | number | boolean | null>(customizer: lodash.CloneWithCustomizer<T, TResult>, value: T): TResult;
@@ -300,13 +303,13 @@ declare namespace _ {
300
303
  }
301
304
  type LodashCloneWith2x1<T, TResult> = (value: T) => TResult | T;
302
305
  type LodashCompact = <T>(array: lodash.List<T | null | undefined | false | "" | 0> | null | undefined) => T[];
303
- interface LodashNegate {
306
+ interface LodashNegate extends LodashConvertible {
304
307
  (predicate: () => boolean): () => boolean;
305
308
  <A1>(predicate: (a1: A1) => boolean): (a1: A1) => boolean;
306
309
  <A1, A2>(predicate: (a1: A1, a2: A2) => boolean): (a1: A1, a2: A2) => boolean;
307
310
  (predicate: (...args: any[]) => any): (...args: any[]) => boolean;
308
311
  }
309
- interface LodashFlowRight {
312
+ interface LodashFlowRight extends LodashConvertible {
310
313
  <R2, R1>(f2: (a: R1) => R2, f1: () => R1): () => R2;
311
314
  <R3, R2, R1>(f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R3;
312
315
  <R4, R3, R2, R1>(f4: (a: R3) => R4, f3: (a: R2) => R3, f2: (a: R1) => R2, f1: () => R1): () => R4;
@@ -346,7 +349,7 @@ declare namespace _ {
346
349
  (f7: (a: any) => any, f6: (a: any) => any, f5: (a: any) => any, f4: (a: any) => any, f3: (a: any) => any, f2: (a: any) => any, f1: () => any, ...funcs: Array<lodash.Many<(...args: any[]) => any>>): (...args: any[]) => any;
347
350
  (funcs: Array<lodash.Many<(...args: any[]) => any>>): (...args: any[]) => any;
348
351
  }
349
- interface LodashConcat {
352
+ interface LodashConcat extends LodashConvertible {
350
353
  <T>(array: lodash.Many<T>): LodashConcat1x1<T>;
351
354
  <T>(array: lodash.__, values: lodash.Many<T>): LodashConcat1x2<T>;
352
355
  <T>(array: lodash.Many<T>, values: lodash.Many<T>): T[];
@@ -354,21 +357,21 @@ declare namespace _ {
354
357
  type LodashConcat1x1<T> = (values: lodash.Many<T>) => T[];
355
358
  type LodashConcat1x2<T> = (array: lodash.Many<T>) => T[];
356
359
  type LodashCond = <T, R>(pairs: Array<lodash.CondPair<T, R>>) => (Target: T) => R;
357
- interface LodashConformsTo {
360
+ interface LodashConformsTo extends LodashConvertible {
358
361
  <T>(source: lodash.ConformsPredicateObject<T>): LodashConformsTo1x1<T>;
359
362
  <T>(source: lodash.__, object: T): LodashConformsTo1x2<T>;
360
363
  <T>(source: lodash.ConformsPredicateObject<T>, object: T): boolean;
361
364
  }
362
365
  type LodashConformsTo1x1<T> = (object: T) => boolean;
363
366
  type LodashConformsTo1x2<T> = (source: lodash.ConformsPredicateObject<T>) => boolean;
364
- interface LodashContains {
367
+ interface LodashContains extends LodashConvertible {
365
368
  <T>(target: T): LodashContains1x1<T>;
366
369
  <T>(target: lodash.__, collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashContains1x2<T>;
367
370
  <T>(target: T, collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean;
368
371
  }
369
372
  type LodashContains1x1<T> = (collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => boolean;
370
373
  type LodashContains1x2<T> = (target: T) => boolean;
371
- interface LodashCountBy {
374
+ interface LodashCountBy extends LodashConvertible {
372
375
  <T>(iteratee: lodash.ValueIteratee<T>): LodashCountBy1x1<T>;
373
376
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashCountBy1x2<T>;
374
377
  <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<number>;
@@ -379,7 +382,7 @@ declare namespace _ {
379
382
  type LodashCountBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => lodash.Dictionary<number>;
380
383
  type LodashCountBy2x2<T> = (iteratee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<number>;
381
384
  type LodashCreate = <T extends object, U extends object>(prototype: T) => T & U;
382
- interface LodashCurry {
385
+ interface LodashCurry extends LodashConvertible {
383
386
  <T1, R>(func: (t1: T1) => R): lodash.CurriedFunction1<T1, R>;
384
387
  <T1, T2, R>(func: (t1: T1, t2: T2) => R): lodash.CurriedFunction2<T1, T2, R>;
385
388
  <T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R): lodash.CurriedFunction3<T1, T2, T3, R>;
@@ -388,7 +391,7 @@ declare namespace _ {
388
391
  (func: (...args: any[]) => any): (...args: any[]) => any;
389
392
  placeholder: lodash.__;
390
393
  }
391
- interface LodashCurryN {
394
+ interface LodashCurryN extends LodashConvertible {
392
395
  (arity: number): LodashCurryN1x1;
393
396
  <T1, R>(arity: lodash.__, func: (t1: T1) => R): LodashCurryN1x2<T1, R>;
394
397
  <T1, R>(arity: number, func: (t1: T1) => R): lodash.CurriedFunction1<T1, R>;
@@ -418,7 +421,7 @@ declare namespace _ {
418
421
  type LodashCurryN4x2<T1, T2, T3, T4, R> = (arity: number) => lodash.CurriedFunction4<T1, T2, T3, T4, R>;
419
422
  type LodashCurryN5x2<T1, T2, T3, T4, T5, R> = (arity: number) => lodash.CurriedFunction5<T1, T2, T3, T4, T5, R>;
420
423
  type LodashCurryN6x2 = (arity: number) => (...args: any[]) => any;
421
- interface LodashCurryRight {
424
+ interface LodashCurryRight extends LodashConvertible {
422
425
  <T1, R>(func: (t1: T1) => R): lodash.RightCurriedFunction1<T1, R>;
423
426
  <T1, T2, R>(func: (t1: T1, t2: T2) => R): lodash.RightCurriedFunction2<T1, T2, R>;
424
427
  <T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3) => R): lodash.RightCurriedFunction3<T1, T2, T3, R>;
@@ -427,7 +430,7 @@ declare namespace _ {
427
430
  (func: (...args: any[]) => any): (...args: any[]) => any;
428
431
  placeholder: lodash.__;
429
432
  }
430
- interface LodashCurryRightN {
433
+ interface LodashCurryRightN extends LodashConvertible {
431
434
  (arity: number): LodashCurryRightN1x1;
432
435
  <T1, R>(arity: lodash.__, func: (t1: T1) => R): LodashCurryRightN1x2<T1, R>;
433
436
  <T1, R>(arity: number, func: (t1: T1) => R): lodash.RightCurriedFunction1<T1, R>;
@@ -457,7 +460,7 @@ declare namespace _ {
457
460
  type LodashCurryRightN4x2<T1, T2, T3, T4, R> = (arity: number) => lodash.RightCurriedFunction4<T1, T2, T3, T4, R>;
458
461
  type LodashCurryRightN5x2<T1, T2, T3, T4, T5, R> = (arity: number) => lodash.RightCurriedFunction5<T1, T2, T3, T4, T5, R>;
459
462
  type LodashCurryRightN6x2 = (arity: number) => (...args: any[]) => any;
460
- interface LodashDebounce {
463
+ interface LodashDebounce extends LodashConvertible {
461
464
  (wait: number): LodashDebounce1x1;
462
465
  <T extends (...args: any[]) => any>(wait: lodash.__, func: T): LodashDebounce1x2<T>;
463
466
  <T extends (...args: any[]) => any>(wait: number, func: T): T & lodash.Cancelable;
@@ -465,14 +468,14 @@ declare namespace _ {
465
468
  type LodashDebounce1x1 = <T extends (...args: any[]) => any>(func: T) => T & lodash.Cancelable;
466
469
  type LodashDebounce1x2<T> = (wait: number) => T & lodash.Cancelable;
467
470
  type LodashDeburr = (string: string) => string;
468
- interface LodashDefaults {
471
+ interface LodashDefaults extends LodashConvertible {
469
472
  <TSource>(source: TSource): LodashDefaults1x1<TSource>;
470
473
  <TObject>(source: lodash.__, object: TObject): LodashDefaults1x2<TObject>;
471
474
  <TObject, TSource>(source: TSource, object: TObject): NonNullable<TSource & TObject>;
472
475
  }
473
476
  type LodashDefaults1x1<TSource> = <TObject>(object: TObject) => NonNullable<TSource & TObject>;
474
477
  type LodashDefaults1x2<TObject> = <TSource>(source: TSource) => NonNullable<TSource & TObject>;
475
- interface LodashDefaultsAll {
478
+ interface LodashDefaultsAll extends LodashConvertible {
476
479
  <TObject, TSource>(object: [TObject, TSource]): NonNullable<TSource & TObject>;
477
480
  <TObject, TSource1, TSource2>(object: [TObject, TSource1, TSource2]): NonNullable<TSource2 & TSource1 & TObject>;
478
481
  <TObject, TSource1, TSource2, TSource3>(object: [TObject, TSource1, TSource2, TSource3]): NonNullable<TSource3 & TSource2 & TSource1 & TObject>;
@@ -480,7 +483,7 @@ declare namespace _ {
480
483
  <TObject>(object: [TObject]): NonNullable<TObject>;
481
484
  (object: ReadonlyArray<any>): any;
482
485
  }
483
- interface LodashDefaultsDeep {
486
+ interface LodashDefaultsDeep extends LodashConvertible {
484
487
  (sources: any): LodashDefaultsDeep1x1;
485
488
  (sources: lodash.__, object: any): LodashDefaultsDeep1x2;
486
489
  (sources: any, object: any): any;
@@ -488,7 +491,7 @@ declare namespace _ {
488
491
  type LodashDefaultsDeep1x1 = (object: any) => any;
489
492
  type LodashDefaultsDeep1x2 = (sources: any) => any;
490
493
  type LodashDefaultsDeepAll = (object: ReadonlyArray<any>) => any;
491
- interface LodashDefaultTo {
494
+ interface LodashDefaultTo extends LodashConvertible {
492
495
  <T>(defaultValue: T): LodashDefaultTo1x1<T>;
493
496
  <T>(defaultValue: lodash.__, value: T | null | undefined): LodashDefaultTo1x2<T>;
494
497
  <T>(defaultValue: T, value: T | null | undefined): T;
@@ -502,21 +505,21 @@ declare namespace _ {
502
505
  }
503
506
  type LodashDefaultTo2x1<TDefault> = <T>(value: T | null | undefined) => T | TDefault;
504
507
  type LodashDefer = (func: (...args: any[]) => any, ...args: any[]) => number;
505
- interface LodashDelay {
508
+ interface LodashDelay extends LodashConvertible {
506
509
  (wait: number): LodashDelay1x1;
507
510
  (wait: lodash.__, func: (...args: any[]) => any): LodashDelay1x2;
508
511
  (wait: number, func: (...args: any[]) => any): number;
509
512
  }
510
513
  type LodashDelay1x1 = (func: (...args: any[]) => any) => number;
511
514
  type LodashDelay1x2 = (wait: number) => number;
512
- interface LodashDifference {
515
+ interface LodashDifference extends LodashConvertible {
513
516
  <T>(array: lodash.List<T> | null | undefined): LodashDifference1x1<T>;
514
517
  <T>(array: lodash.__, values: lodash.List<T>): LodashDifference1x2<T>;
515
518
  <T>(array: lodash.List<T> | null | undefined, values: lodash.List<T>): T[];
516
519
  }
517
520
  type LodashDifference1x1<T> = (values: lodash.List<T>) => T[];
518
521
  type LodashDifference1x2<T> = (array: lodash.List<T> | null | undefined) => T[];
519
- interface LodashDifferenceBy {
522
+ interface LodashDifferenceBy extends LodashConvertible {
520
523
  <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashDifferenceBy1x1<T1, T2>;
521
524
  <T1>(iteratee: lodash.__, array: lodash.List<T1> | null | undefined): LodashDifferenceBy1x2<T1>;
522
525
  <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.List<T1> | null | undefined): LodashDifferenceBy1x3<T1, T2>;
@@ -543,7 +546,7 @@ declare namespace _ {
543
546
  }
544
547
  type LodashDifferenceBy1x5<T1> = (array: lodash.List<T1> | null | undefined) => T1[];
545
548
  type LodashDifferenceBy1x6<T1, T2> = (iteratee: lodash.ValueIteratee<T1 | T2>) => T1[];
546
- interface LodashDifferenceWith {
549
+ interface LodashDifferenceWith extends LodashConvertible {
547
550
  <T1, T2>(comparator: lodash.Comparator2<T1, T2>): LodashDifferenceWith1x1<T1, T2>;
548
551
  <T1>(comparator: lodash.__, array: lodash.List<T1> | null | undefined): LodashDifferenceWith1x2<T1>;
549
552
  <T1, T2>(comparator: lodash.Comparator2<T1, T2>, array: lodash.List<T1> | null | undefined): LodashDifferenceWith1x3<T1, T2>;
@@ -570,49 +573,49 @@ declare namespace _ {
570
573
  }
571
574
  type LodashDifferenceWith1x5<T1> = (array: lodash.List<T1> | null | undefined) => T1[];
572
575
  type LodashDifferenceWith1x6<T1, T2> = (comparator: lodash.Comparator2<T1, T2>) => T1[];
573
- interface LodashUnset {
576
+ interface LodashUnset extends LodashConvertible {
574
577
  (path: lodash.PropertyPath): LodashUnset1x1;
575
578
  <T>(path: lodash.__, object: T): LodashUnset1x2<T>;
576
579
  <T>(path: lodash.PropertyPath, object: T): T;
577
580
  }
578
581
  type LodashUnset1x1 = <T>(object: T) => T;
579
582
  type LodashUnset1x2<T> = (path: lodash.PropertyPath) => T;
580
- interface LodashDivide {
583
+ interface LodashDivide extends LodashConvertible {
581
584
  (dividend: number): LodashDivide1x1;
582
585
  (dividend: lodash.__, divisor: number): LodashDivide1x2;
583
586
  (dividend: number, divisor: number): number;
584
587
  }
585
588
  type LodashDivide1x1 = (divisor: number) => number;
586
589
  type LodashDivide1x2 = (dividend: number) => number;
587
- interface LodashDrop {
590
+ interface LodashDrop extends LodashConvertible {
588
591
  (n: number): LodashDrop1x1;
589
592
  <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashDrop1x2<T>;
590
593
  <T>(n: number, array: lodash.List<T> | null | undefined): T[];
591
594
  }
592
595
  type LodashDrop1x1 = <T>(array: lodash.List<T> | null | undefined) => T[];
593
596
  type LodashDrop1x2<T> = (n: number) => T[];
594
- interface LodashDropRight {
597
+ interface LodashDropRight extends LodashConvertible {
595
598
  (n: number): LodashDropRight1x1;
596
599
  <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashDropRight1x2<T>;
597
600
  <T>(n: number, array: lodash.List<T> | null | undefined): T[];
598
601
  }
599
602
  type LodashDropRight1x1 = <T>(array: lodash.List<T> | null | undefined) => T[];
600
603
  type LodashDropRight1x2<T> = (n: number) => T[];
601
- interface LodashDropRightWhile {
604
+ interface LodashDropRightWhile extends LodashConvertible {
602
605
  <T>(predicate: lodash.ValueIteratee<T>): LodashDropRightWhile1x1<T>;
603
606
  <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashDropRightWhile1x2<T>;
604
607
  <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
605
608
  }
606
609
  type LodashDropRightWhile1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
607
610
  type LodashDropRightWhile1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
608
- interface LodashDropWhile {
611
+ interface LodashDropWhile extends LodashConvertible {
609
612
  <T>(predicate: lodash.ValueIteratee<T>): LodashDropWhile1x1<T>;
610
613
  <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashDropWhile1x2<T>;
611
614
  <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
612
615
  }
613
616
  type LodashDropWhile1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
614
617
  type LodashDropWhile1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
615
- interface LodashForEach {
618
+ interface LodashForEach extends LodashConvertible {
616
619
  <T>(iteratee: (value: T) => any): LodashForEach1x1<T>;
617
620
  <T>(iteratee: lodash.__, collection: ReadonlyArray<T>): LodashForEach1x2<T>;
618
621
  <T>(iteratee: (value: T) => any, collection: ReadonlyArray<T>): T[];
@@ -641,7 +644,7 @@ declare namespace _ {
641
644
  type LodashForEach4x2<T, TArray> = (iteratee: (value: T) => any) => TArray;
642
645
  type LodashForEach5x2<T, TList> = (iteratee: (value: T) => any) => TList;
643
646
  type LodashForEach6x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
644
- interface LodashForEachRight {
647
+ interface LodashForEachRight extends LodashConvertible {
645
648
  <T>(iteratee: (value: T) => any): LodashForEachRight1x1<T>;
646
649
  <T>(iteratee: lodash.__, collection: ReadonlyArray<T>): LodashForEachRight1x2<T>;
647
650
  <T>(iteratee: (value: T) => any, collection: ReadonlyArray<T>): T[];
@@ -670,29 +673,29 @@ declare namespace _ {
670
673
  type LodashForEachRight4x2<T, TArray> = (iteratee: (value: T) => any) => TArray;
671
674
  type LodashForEachRight5x2<T, TList> = (iteratee: (value: T) => any) => TList;
672
675
  type LodashForEachRight6x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
673
- interface LodashEndsWith {
676
+ interface LodashEndsWith extends LodashConvertible {
674
677
  (target: string): LodashEndsWith1x1;
675
678
  (target: lodash.__, string: string): LodashEndsWith1x2;
676
679
  (target: string, string: string): boolean;
677
680
  }
678
681
  type LodashEndsWith1x1 = (string: string) => boolean;
679
682
  type LodashEndsWith1x2 = (target: string) => boolean;
680
- interface LodashToPairs {
683
+ interface LodashToPairs extends LodashConvertible {
681
684
  <T>(object: lodash.Dictionary<T> | lodash.NumericDictionary<T>): Array<[string, T]>;
682
685
  (object: object): Array<[string, any]>;
683
686
  }
684
- interface LodashToPairsIn {
687
+ interface LodashToPairsIn extends LodashConvertible {
685
688
  <T>(object: lodash.Dictionary<T> | lodash.NumericDictionary<T>): Array<[string, T]>;
686
689
  (object: object): Array<[string, any]>;
687
690
  }
688
- interface LodashEq {
691
+ interface LodashEq extends LodashConvertible {
689
692
  (value: any): LodashEq1x1;
690
693
  (value: lodash.__, other: any): LodashEq1x2;
691
694
  (value: any, other: any): boolean;
692
695
  }
693
696
  type LodashEq1x1 = (other: any) => boolean;
694
697
  type LodashEq1x2 = (value: any) => boolean;
695
- interface LodashIsEqual {
698
+ interface LodashIsEqual extends LodashConvertible {
696
699
  (value: any): LodashIsEqual1x1;
697
700
  (value: lodash.__, other: any): LodashIsEqual1x2;
698
701
  (value: any, other: any): boolean;
@@ -701,14 +704,14 @@ declare namespace _ {
701
704
  type LodashIsEqual1x2 = (value: any) => boolean;
702
705
  type LodashEscape = (string: string) => string;
703
706
  type LodashEscapeRegExp = (string: string) => string;
704
- interface LodashExtend {
707
+ interface LodashExtend extends LodashConvertible {
705
708
  <TObject>(object: TObject): LodashExtend1x1<TObject>;
706
709
  <TSource>(object: lodash.__, source: TSource): LodashExtend1x2<TSource>;
707
710
  <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
708
711
  }
709
712
  type LodashExtend1x1<TObject> = <TSource>(source: TSource) => TObject & TSource;
710
713
  type LodashExtend1x2<TSource> = <TObject>(object: TObject) => TObject & TSource;
711
- interface LodashExtendAll {
714
+ interface LodashExtendAll extends LodashConvertible {
712
715
  <TObject, TSource>(object: [TObject, TSource]): TObject & TSource;
713
716
  <TObject, TSource1, TSource2>(object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2;
714
717
  <TObject, TSource1, TSource2, TSource3>(object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3;
@@ -716,14 +719,14 @@ declare namespace _ {
716
719
  <TObject>(object: [TObject]): TObject;
717
720
  <TResult>(object: ReadonlyArray<any>): TResult;
718
721
  }
719
- interface LodashExtendAllWith {
722
+ interface LodashExtendAllWith extends LodashConvertible {
720
723
  (customizer: lodash.AssignCustomizer): LodashExtendAllWith1x1;
721
724
  (customizer: lodash.__, args: ReadonlyArray<any>): LodashExtendAllWith1x2;
722
725
  (customizer: lodash.AssignCustomizer, args: ReadonlyArray<any>): any;
723
726
  }
724
727
  type LodashExtendAllWith1x1 = (args: ReadonlyArray<any>) => any;
725
728
  type LodashExtendAllWith1x2 = (customizer: lodash.AssignCustomizer) => any;
726
- interface LodashExtendWith {
729
+ interface LodashExtendWith extends LodashConvertible {
727
730
  (customizer: lodash.AssignCustomizer): LodashExtendWith1x1;
728
731
  <TObject>(customizer: lodash.__, object: TObject): LodashExtendWith1x2<TObject>;
729
732
  <TObject>(customizer: lodash.AssignCustomizer, object: TObject): LodashExtendWith1x3<TObject>;
@@ -751,7 +754,7 @@ declare namespace _ {
751
754
  type LodashExtendWith1x5<TSource> = <TObject>(object: TObject) => TObject & TSource;
752
755
  type LodashExtendWith1x6<TObject, TSource> = (customizer: lodash.AssignCustomizer) => TObject & TSource;
753
756
  type LodashStubFalse = () => false;
754
- interface LodashFill {
757
+ interface LodashFill extends LodashConvertible {
755
758
  (start: number): LodashFill1x1;
756
759
  (start: lodash.__, end: number): LodashFill1x2;
757
760
  (start: number, end: number): LodashFill1x3;
@@ -894,7 +897,7 @@ declare namespace _ {
894
897
  }
895
898
  type LodashFill2x13<T, U> = (end: number) => lodash.List<T | U>;
896
899
  type LodashFill2x14<T, U> = (start: number) => lodash.List<T | U>;
897
- interface LodashFilter {
900
+ interface LodashFilter extends LodashConvertible {
898
901
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>): LodashFilter1x1<T, S>;
899
902
  <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashFilter1x2<T>;
900
903
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>, collection: lodash.List<T> | null | undefined): S[];
@@ -916,7 +919,7 @@ declare namespace _ {
916
919
  <S extends T[keyof T]>(predicate: lodash.ValueIteratorTypeGuard<T[keyof T], S>): S[];
917
920
  (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>): Array<T[keyof T]>;
918
921
  }
919
- interface LodashFind {
922
+ interface LodashFind extends LodashConvertible {
920
923
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>): LodashFind1x1<T, S>;
921
924
  <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashFind1x2<T>;
922
925
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>, collection: lodash.List<T> | null | undefined): S|undefined;
@@ -938,7 +941,7 @@ declare namespace _ {
938
941
  <S extends T[keyof T]>(predicate: lodash.ValueIteratorTypeGuard<T[keyof T], S>): S|undefined;
939
942
  (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>): T[keyof T]|undefined;
940
943
  }
941
- interface LodashFindFrom {
944
+ interface LodashFindFrom extends LodashConvertible {
942
945
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>): LodashFindFrom1x1<T, S>;
943
946
  (predicate: lodash.__, fromIndex: number): LodashFindFrom1x2;
944
947
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>, fromIndex: number): LodashFindFrom1x3<T, S>;
@@ -1018,14 +1021,14 @@ declare namespace _ {
1018
1021
  (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>): T[keyof T]|undefined;
1019
1022
  }
1020
1023
  type LodashFindFrom4x5<T> = (fromIndex: number) => T[keyof T]|undefined;
1021
- interface LodashFindIndex {
1024
+ interface LodashFindIndex extends LodashConvertible {
1022
1025
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashFindIndex1x1<T>;
1023
1026
  <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashFindIndex1x2<T>;
1024
1027
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, array: lodash.List<T> | null | undefined): number;
1025
1028
  }
1026
1029
  type LodashFindIndex1x1<T> = (array: lodash.List<T> | null | undefined) => number;
1027
1030
  type LodashFindIndex1x2<T> = (predicate: lodash.ValueIterateeCustom<T, boolean>) => number;
1028
- interface LodashFindIndexFrom {
1031
+ interface LodashFindIndexFrom extends LodashConvertible {
1029
1032
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashFindIndexFrom1x1<T>;
1030
1033
  (predicate: lodash.__, fromIndex: number): LodashFindIndexFrom1x2;
1031
1034
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, fromIndex: number): LodashFindIndexFrom1x3<T>;
@@ -1052,14 +1055,14 @@ declare namespace _ {
1052
1055
  }
1053
1056
  type LodashFindIndexFrom1x5 = (fromIndex: number) => number;
1054
1057
  type LodashFindIndexFrom1x6<T> = (predicate: lodash.ValueIterateeCustom<T, boolean>) => number;
1055
- interface LodashFindKey {
1058
+ interface LodashFindKey extends LodashConvertible {
1056
1059
  <T>(predicate: lodash.ValueIteratee<T>): LodashFindKey1x1<T>;
1057
1060
  <T>(predicate: lodash.__, object: T | null | undefined): LodashFindKey1x2<T>;
1058
1061
  <T>(predicate: lodash.ValueIteratee<T[keyof T]>, object: T | null | undefined): string | undefined;
1059
1062
  }
1060
1063
  type LodashFindKey1x1<T> = (object: object | null | undefined) => string | undefined;
1061
1064
  type LodashFindKey1x2<T> = (predicate: lodash.ValueIteratee<T[keyof T]>) => string | undefined;
1062
- interface LodashFindLast {
1065
+ interface LodashFindLast extends LodashConvertible {
1063
1066
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>): LodashFindLast1x1<T, S>;
1064
1067
  <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashFindLast1x2<T>;
1065
1068
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>, collection: lodash.List<T> | null | undefined): S|undefined;
@@ -1081,7 +1084,7 @@ declare namespace _ {
1081
1084
  <S extends T[keyof T]>(predicate: lodash.ValueIteratorTypeGuard<T[keyof T], S>): S|undefined;
1082
1085
  (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>): T[keyof T]|undefined;
1083
1086
  }
1084
- interface LodashFindLastFrom {
1087
+ interface LodashFindLastFrom extends LodashConvertible {
1085
1088
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>): LodashFindLastFrom1x1<T, S>;
1086
1089
  (predicate: lodash.__, fromIndex: number): LodashFindLastFrom1x2;
1087
1090
  <T, S extends T>(predicate: lodash.ValueIteratorTypeGuard<T, S>, fromIndex: number): LodashFindLastFrom1x3<T, S>;
@@ -1161,14 +1164,14 @@ declare namespace _ {
1161
1164
  (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>): T[keyof T]|undefined;
1162
1165
  }
1163
1166
  type LodashFindLastFrom4x5<T> = (fromIndex: number) => T[keyof T]|undefined;
1164
- interface LodashFindLastIndex {
1167
+ interface LodashFindLastIndex extends LodashConvertible {
1165
1168
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashFindLastIndex1x1<T>;
1166
1169
  <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashFindLastIndex1x2<T>;
1167
1170
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, array: lodash.List<T> | null | undefined): number;
1168
1171
  }
1169
1172
  type LodashFindLastIndex1x1<T> = (array: lodash.List<T> | null | undefined) => number;
1170
1173
  type LodashFindLastIndex1x2<T> = (predicate: lodash.ValueIterateeCustom<T, boolean>) => number;
1171
- interface LodashFindLastIndexFrom {
1174
+ interface LodashFindLastIndexFrom extends LodashConvertible {
1172
1175
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashFindLastIndexFrom1x1<T>;
1173
1176
  (predicate: lodash.__, fromIndex: number): LodashFindLastIndexFrom1x2;
1174
1177
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, fromIndex: number): LodashFindLastIndexFrom1x3<T>;
@@ -1195,7 +1198,7 @@ declare namespace _ {
1195
1198
  }
1196
1199
  type LodashFindLastIndexFrom1x5 = (fromIndex: number) => number;
1197
1200
  type LodashFindLastIndexFrom1x6<T> = (predicate: lodash.ValueIterateeCustom<T, boolean>) => number;
1198
- interface LodashFindLastKey {
1201
+ interface LodashFindLastKey extends LodashConvertible {
1199
1202
  <T>(predicate: lodash.ValueIteratee<T>): LodashFindLastKey1x1<T>;
1200
1203
  <T>(predicate: lodash.__, object: T | null | undefined): LodashFindLastKey1x2<T>;
1201
1204
  <T>(predicate: lodash.ValueIteratee<T[keyof T]>, object: T | null | undefined): string | undefined;
@@ -1203,7 +1206,7 @@ declare namespace _ {
1203
1206
  type LodashFindLastKey1x1<T> = (object: object | null | undefined) => string | undefined;
1204
1207
  type LodashFindLastKey1x2<T> = (predicate: lodash.ValueIteratee<T[keyof T]>) => string | undefined;
1205
1208
  type LodashHead = <T>(array: lodash.List<T> | null | undefined) => T | undefined;
1206
- interface LodashFlatMap {
1209
+ interface LodashFlatMap extends LodashConvertible {
1207
1210
  <T, TResult>(iteratee: (value: T) => lodash.Many<TResult>): LodashFlatMap1x1<T, TResult>;
1208
1211
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashFlatMap1x2<T>;
1209
1212
  <T, TResult>(iteratee: (value: T) => lodash.Many<TResult>, collection: lodash.List<T> | null | undefined): TResult[];
@@ -1226,7 +1229,7 @@ declare namespace _ {
1226
1229
  (iteratee: object): boolean[];
1227
1230
  }
1228
1231
  type LodashFlatMap4x1 = (collection: object | null | undefined) => boolean[];
1229
- interface LodashFlatMapDeep {
1232
+ interface LodashFlatMapDeep extends LodashConvertible {
1230
1233
  <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDeep1x1<T, TResult>;
1231
1234
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashFlatMapDeep1x2<T>;
1232
1235
  <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, collection: lodash.List<T> | null | undefined): TResult[];
@@ -1249,7 +1252,7 @@ declare namespace _ {
1249
1252
  (iteratee: object): boolean[];
1250
1253
  }
1251
1254
  type LodashFlatMapDeep4x1 = (collection: object | null | undefined) => boolean[];
1252
- interface LodashFlatMapDepth {
1255
+ interface LodashFlatMapDepth extends LodashConvertible {
1253
1256
  <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDepth1x1<T, TResult>;
1254
1257
  (iteratee: lodash.__, depth: number): LodashFlatMapDepth1x2;
1255
1258
  <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: number): LodashFlatMapDepth1x3<T, TResult>;
@@ -1340,7 +1343,7 @@ declare namespace _ {
1340
1343
  type LodashFlatMapDepth4x5 = (depth: number) => boolean[];
1341
1344
  type LodashFlatten = <T>(array: lodash.List<lodash.Many<T>> | null | undefined) => T[];
1342
1345
  type LodashFlattenDeep = <T>(array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined) => T[];
1343
- interface LodashFlattenDepth {
1346
+ interface LodashFlattenDepth extends LodashConvertible {
1344
1347
  (depth: number): LodashFlattenDepth1x1;
1345
1348
  <T>(depth: lodash.__, array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined): LodashFlattenDepth1x2<T>;
1346
1349
  <T>(depth: number, array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined): T[];
@@ -1349,7 +1352,7 @@ declare namespace _ {
1349
1352
  type LodashFlattenDepth1x2<T> = (depth: number) => T[];
1350
1353
  type LodashFlip = <T extends (...args: any[]) => any>(func: T) => T;
1351
1354
  type LodashFloor = (n: number) => number;
1352
- interface LodashFlow {
1355
+ interface LodashFlow extends LodashConvertible {
1353
1356
  <R1, R2>(f1: () => R1, f2: (a: R1) => R2): () => R2;
1354
1357
  <R1, R2, R3>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): () => R3;
1355
1358
  <R1, R2, R3, R4>(f1: () => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): () => R4;
@@ -1394,7 +1397,7 @@ declare namespace _ {
1394
1397
  <A1, A2, A3, A4, R1, R2, R3, R4, R5, R6, R7>(f1: (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6, f7: (a: R6) => R7, ...funcs: Array<lodash.Many<(a: any) => any>>): (a1: A1, a2: A2, a3: A3, a4: A4, ...args: any[]) => any;
1395
1398
  (funcs: Array<lodash.Many<(...args: any[]) => any>>): (...args: any[]) => any;
1396
1399
  }
1397
- interface LodashForIn {
1400
+ interface LodashForIn extends LodashConvertible {
1398
1401
  <T>(iteratee: (value: T) => any): LodashForIn1x1<T>;
1399
1402
  <T>(iteratee: lodash.__, object: T): LodashForIn1x2<T>;
1400
1403
  <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
@@ -1407,7 +1410,7 @@ declare namespace _ {
1407
1410
  }
1408
1411
  type LodashForIn1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
1409
1412
  type LodashForIn2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
1410
- interface LodashForInRight {
1413
+ interface LodashForInRight extends LodashConvertible {
1411
1414
  <T>(iteratee: (value: T) => any): LodashForInRight1x1<T>;
1412
1415
  <T>(iteratee: lodash.__, object: T): LodashForInRight1x2<T>;
1413
1416
  <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
@@ -1420,7 +1423,7 @@ declare namespace _ {
1420
1423
  }
1421
1424
  type LodashForInRight1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
1422
1425
  type LodashForInRight2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
1423
- interface LodashForOwn {
1426
+ interface LodashForOwn extends LodashConvertible {
1424
1427
  <T>(iteratee: (value: T) => any): LodashForOwn1x1<T>;
1425
1428
  <T>(iteratee: lodash.__, object: T): LodashForOwn1x2<T>;
1426
1429
  <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
@@ -1433,7 +1436,7 @@ declare namespace _ {
1433
1436
  }
1434
1437
  type LodashForOwn1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
1435
1438
  type LodashForOwn2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
1436
- interface LodashForOwnRight {
1439
+ interface LodashForOwnRight extends LodashConvertible {
1437
1440
  <T>(iteratee: (value: T) => any): LodashForOwnRight1x1<T>;
1438
1441
  <T>(iteratee: lodash.__, object: T): LodashForOwnRight1x2<T>;
1439
1442
  <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
@@ -1446,13 +1449,13 @@ declare namespace _ {
1446
1449
  }
1447
1450
  type LodashForOwnRight1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
1448
1451
  type LodashForOwnRight2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
1449
- interface LodashFromPairs {
1452
+ interface LodashFromPairs extends LodashConvertible {
1450
1453
  <T>(pairs: lodash.List<[lodash.PropertyName, T]> | null | undefined): lodash.Dictionary<T>;
1451
1454
  (pairs: lodash.List<any[]> | null | undefined): lodash.Dictionary<any>;
1452
1455
  }
1453
1456
  type LodashFunctions = (object: any) => string[];
1454
1457
  type LodashFunctionsIn = (object: any) => string[];
1455
- interface LodashGet {
1458
+ interface LodashGet extends LodashConvertible {
1456
1459
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashGet1x1<TObject, TKey>;
1457
1460
  <TObject extends object>(path: lodash.__, object: TObject): LodashGet1x2<TObject>;
1458
1461
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
@@ -1501,7 +1504,7 @@ declare namespace _ {
1501
1504
  }
1502
1505
  type LodashGet8x2 = (path: lodash.PropertyPath) => undefined;
1503
1506
  type LodashGet9x2 = (path: lodash.PropertyPath) => any;
1504
- interface LodashGetOr {
1507
+ interface LodashGetOr extends LodashConvertible {
1505
1508
  <TDefault>(defaultValue: TDefault): LodashGetOr1x1<TDefault>;
1506
1509
  <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashGetOr1x2<TObject, TKey>;
1507
1510
  <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): LodashGetOr1x3<TObject, TKey, TDefault>;
@@ -1644,7 +1647,7 @@ declare namespace _ {
1644
1647
  }
1645
1648
  type LodashGetOr7x5 = (path: lodash.PropertyPath) => any;
1646
1649
  type LodashGetOr7x6 = (defaultValue: any) => any;
1647
- interface LodashGroupBy {
1650
+ interface LodashGroupBy extends LodashConvertible {
1648
1651
  <T>(iteratee: lodash.ValueIteratee<T>): LodashGroupBy1x1<T>;
1649
1652
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashGroupBy1x2<T>;
1650
1653
  <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<T[]>;
@@ -1654,46 +1657,46 @@ declare namespace _ {
1654
1657
  type LodashGroupBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => lodash.Dictionary<T[]>;
1655
1658
  type LodashGroupBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => lodash.Dictionary<T[]>;
1656
1659
  type LodashGroupBy2x2<T> = (iteratee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<Array<T[keyof T]>>;
1657
- interface LodashGt {
1660
+ interface LodashGt extends LodashConvertible {
1658
1661
  (value: any): LodashGt1x1;
1659
1662
  (value: lodash.__, other: any): LodashGt1x2;
1660
1663
  (value: any, other: any): boolean;
1661
1664
  }
1662
1665
  type LodashGt1x1 = (other: any) => boolean;
1663
1666
  type LodashGt1x2 = (value: any) => boolean;
1664
- interface LodashGte {
1667
+ interface LodashGte extends LodashConvertible {
1665
1668
  (value: any): LodashGte1x1;
1666
1669
  (value: lodash.__, other: any): LodashGte1x2;
1667
1670
  (value: any, other: any): boolean;
1668
1671
  }
1669
1672
  type LodashGte1x1 = (other: any) => boolean;
1670
1673
  type LodashGte1x2 = (value: any) => boolean;
1671
- interface LodashHas {
1674
+ interface LodashHas extends LodashConvertible {
1672
1675
  (path: lodash.PropertyPath): LodashHas1x1;
1673
1676
  <T>(path: lodash.__, object: T): LodashHas1x2;
1674
1677
  <T>(path: lodash.PropertyPath, object: T): boolean;
1675
1678
  }
1676
1679
  type LodashHas1x1 = <T>(object: T) => boolean;
1677
1680
  type LodashHas1x2 = (path: lodash.PropertyPath) => boolean;
1678
- interface LodashHasIn {
1681
+ interface LodashHasIn extends LodashConvertible {
1679
1682
  (path: lodash.PropertyPath): LodashHasIn1x1;
1680
1683
  <T>(path: lodash.__, object: T): LodashHasIn1x2;
1681
1684
  <T>(path: lodash.PropertyPath, object: T): boolean;
1682
1685
  }
1683
1686
  type LodashHasIn1x1 = <T>(object: T) => boolean;
1684
1687
  type LodashHasIn1x2 = (path: lodash.PropertyPath) => boolean;
1685
- interface LodashIdentity {
1688
+ interface LodashIdentity extends LodashConvertible {
1686
1689
  <T>(value: T): T;
1687
1690
  (): undefined;
1688
1691
  }
1689
- interface LodashIncludes {
1692
+ interface LodashIncludes extends LodashConvertible {
1690
1693
  <T>(target: T): LodashIncludes1x1<T>;
1691
1694
  <T>(target: lodash.__, collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludes1x2<T>;
1692
1695
  <T>(target: T, collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean;
1693
1696
  }
1694
1697
  type LodashIncludes1x1<T> = (collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => boolean;
1695
1698
  type LodashIncludes1x2<T> = (target: T) => boolean;
1696
- interface LodashIncludesFrom {
1699
+ interface LodashIncludesFrom extends LodashConvertible {
1697
1700
  <T>(target: T): LodashIncludesFrom1x1<T>;
1698
1701
  (target: lodash.__, fromIndex: number): LodashIncludesFrom1x2;
1699
1702
  <T>(target: T, fromIndex: number): LodashIncludesFrom1x3<T>;
@@ -1720,7 +1723,7 @@ declare namespace _ {
1720
1723
  }
1721
1724
  type LodashIncludesFrom1x5 = (fromIndex: number) => boolean;
1722
1725
  type LodashIncludesFrom1x6<T> = (target: T) => boolean;
1723
- interface LodashKeyBy {
1726
+ interface LodashKeyBy extends LodashConvertible {
1724
1727
  <T>(iteratee: lodash.ValueIterateeCustom<T, lodash.PropertyName>): LodashKeyBy1x1<T>;
1725
1728
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashKeyBy1x2<T>;
1726
1729
  <T>(iteratee: lodash.ValueIterateeCustom<T, lodash.PropertyName>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<T>;
@@ -1730,14 +1733,14 @@ declare namespace _ {
1730
1733
  type LodashKeyBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => lodash.Dictionary<T>;
1731
1734
  type LodashKeyBy1x2<T> = (iteratee: lodash.ValueIterateeCustom<T, lodash.PropertyName>) => lodash.Dictionary<T>;
1732
1735
  type LodashKeyBy2x2<T> = (iteratee: lodash.ValueIterateeCustom<T[keyof T], lodash.PropertyName>) => lodash.Dictionary<T[keyof T]>;
1733
- interface LodashIndexOf {
1736
+ interface LodashIndexOf extends LodashConvertible {
1734
1737
  <T>(value: T): LodashIndexOf1x1<T>;
1735
1738
  <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashIndexOf1x2<T>;
1736
1739
  <T>(value: T, array: lodash.List<T> | null | undefined): number;
1737
1740
  }
1738
1741
  type LodashIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
1739
1742
  type LodashIndexOf1x2<T> = (value: T) => number;
1740
- interface LodashIndexOfFrom {
1743
+ interface LodashIndexOfFrom extends LodashConvertible {
1741
1744
  <T>(value: T): LodashIndexOfFrom1x1<T>;
1742
1745
  (value: lodash.__, fromIndex: number): LodashIndexOfFrom1x2;
1743
1746
  <T>(value: T, fromIndex: number): LodashIndexOfFrom1x3<T>;
@@ -1765,7 +1768,7 @@ declare namespace _ {
1765
1768
  type LodashIndexOfFrom1x5 = (fromIndex: number) => number;
1766
1769
  type LodashIndexOfFrom1x6<T> = (value: T) => number;
1767
1770
  type LodashInitial = <T>(array: lodash.List<T> | null | undefined) => T[];
1768
- interface LodashInRange {
1771
+ interface LodashInRange extends LodashConvertible {
1769
1772
  (start: number): LodashInRange1x1;
1770
1773
  (start: lodash.__, end: number): LodashInRange1x2;
1771
1774
  (start: number, end: number): LodashInRange1x3;
@@ -1792,14 +1795,14 @@ declare namespace _ {
1792
1795
  }
1793
1796
  type LodashInRange1x5 = (end: number) => boolean;
1794
1797
  type LodashInRange1x6 = (start: number) => boolean;
1795
- interface LodashIntersection {
1798
+ interface LodashIntersection extends LodashConvertible {
1796
1799
  <T>(arrays2: lodash.List<T>): LodashIntersection1x1<T>;
1797
1800
  <T>(arrays2: lodash.__, arrays: lodash.List<T>): LodashIntersection1x2<T>;
1798
1801
  <T>(arrays2: lodash.List<T>, arrays: lodash.List<T>): T[];
1799
1802
  }
1800
1803
  type LodashIntersection1x1<T> = (arrays: lodash.List<T>) => T[];
1801
1804
  type LodashIntersection1x2<T> = (arrays2: lodash.List<T>) => T[];
1802
- interface LodashIntersectionBy {
1805
+ interface LodashIntersectionBy extends LodashConvertible {
1803
1806
  <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashIntersectionBy1x1<T1, T2>;
1804
1807
  <T1>(iteratee: lodash.__, array: lodash.List<T1> | null): LodashIntersectionBy1x2<T1>;
1805
1808
  <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.List<T1> | null): LodashIntersectionBy1x3<T1, T2>;
@@ -1826,7 +1829,7 @@ declare namespace _ {
1826
1829
  }
1827
1830
  type LodashIntersectionBy1x5<T1> = (array: lodash.List<T1> | null) => T1[];
1828
1831
  type LodashIntersectionBy1x6<T1, T2> = (iteratee: lodash.ValueIteratee<T1 | T2>) => T1[];
1829
- interface LodashIntersectionWith {
1832
+ interface LodashIntersectionWith extends LodashConvertible {
1830
1833
  <T1, T2>(comparator: lodash.Comparator2<T1, T2>): LodashIntersectionWith1x1<T1, T2>;
1831
1834
  <T1>(comparator: lodash.__, array: lodash.List<T1> | null | undefined): LodashIntersectionWith1x2<T1>;
1832
1835
  <T1, T2>(comparator: lodash.Comparator2<T1, T2>, array: lodash.List<T1> | null | undefined): LodashIntersectionWith1x3<T1, T2>;
@@ -1854,7 +1857,7 @@ declare namespace _ {
1854
1857
  type LodashIntersectionWith1x5<T1> = (array: lodash.List<T1> | null | undefined) => T1[];
1855
1858
  type LodashIntersectionWith1x6<T1, T2> = (comparator: lodash.Comparator2<T1, T2>) => T1[];
1856
1859
  type LodashInvert = (object: object) => lodash.Dictionary<string>;
1857
- interface LodashInvertBy {
1860
+ interface LodashInvertBy extends LodashConvertible {
1858
1861
  <T>(interatee: lodash.ValueIteratee<T>): LodashInvertBy1x1<T>;
1859
1862
  <T>(interatee: lodash.__, object: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashInvertBy1x2<T>;
1860
1863
  <T>(interatee: lodash.ValueIteratee<T>, object: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<string[]>;
@@ -1864,14 +1867,14 @@ declare namespace _ {
1864
1867
  type LodashInvertBy1x1<T> = (object: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | object | null | undefined) => lodash.Dictionary<string[]>;
1865
1868
  type LodashInvertBy1x2<T> = (interatee: lodash.ValueIteratee<T>) => lodash.Dictionary<string[]>;
1866
1869
  type LodashInvertBy2x2<T> = (interatee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<string[]>;
1867
- interface LodashInvoke {
1870
+ interface LodashInvoke extends LodashConvertible {
1868
1871
  (path: lodash.PropertyPath): LodashInvoke1x1;
1869
1872
  (path: lodash.__, object: any): LodashInvoke1x2;
1870
1873
  (path: lodash.PropertyPath, object: any): any;
1871
1874
  }
1872
1875
  type LodashInvoke1x1 = (object: any) => any;
1873
1876
  type LodashInvoke1x2 = (path: lodash.PropertyPath) => any;
1874
- interface LodashInvokeArgs {
1877
+ interface LodashInvokeArgs extends LodashConvertible {
1875
1878
  (path: lodash.PropertyPath): LodashInvokeArgs1x1;
1876
1879
  (path: lodash.__, args: ReadonlyArray<any>): LodashInvokeArgs1x2;
1877
1880
  (path: lodash.PropertyPath, args: ReadonlyArray<any>): LodashInvokeArgs1x3;
@@ -1898,7 +1901,7 @@ declare namespace _ {
1898
1901
  }
1899
1902
  type LodashInvokeArgs1x5 = (args: ReadonlyArray<any>) => any;
1900
1903
  type LodashInvokeArgs1x6 = (path: lodash.PropertyPath) => any;
1901
- interface LodashInvokeArgsMap {
1904
+ interface LodashInvokeArgsMap extends LodashConvertible {
1902
1905
  (methodName: string): LodashInvokeArgsMap1x1;
1903
1906
  (methodNameOrMethod: lodash.__, args: ReadonlyArray<any>): LodashInvokeArgsMap1x2;
1904
1907
  (methodName: string, args: ReadonlyArray<any>): LodashInvokeArgsMap1x3;
@@ -1943,7 +1946,7 @@ declare namespace _ {
1943
1946
  }
1944
1947
  type LodashInvokeArgsMap2x3<TResult> = (collection: object | null | undefined) => TResult[];
1945
1948
  type LodashInvokeArgsMap2x5<TResult> = (args: ReadonlyArray<any>) => TResult[];
1946
- interface LodashInvokeMap {
1949
+ interface LodashInvokeMap extends LodashConvertible {
1947
1950
  (methodName: string): LodashInvokeMap1x1;
1948
1951
  (methodNameOrMethod: lodash.__, collection: object | null | undefined): LodashInvokeMap1x2;
1949
1952
  (methodName: string, collection: object | null | undefined): any[];
@@ -1959,12 +1962,12 @@ declare namespace _ {
1959
1962
  type LodashIsArguments = (value: any) => value is IArguments;
1960
1963
  type LodashIsArray = (value: any) => value is any[];
1961
1964
  type LodashIsArrayBuffer = (value: any) => value is ArrayBuffer;
1962
- interface LodashIsArrayLike {
1965
+ interface LodashIsArrayLike extends LodashConvertible {
1963
1966
  <T>(value: T & string & number): boolean;
1964
1967
  (value: ((...args: any[]) => any) | null | undefined): value is never;
1965
1968
  (value: any): value is { length: number };
1966
1969
  }
1967
- interface LodashIsArrayLikeObject {
1970
+ interface LodashIsArrayLikeObject extends LodashConvertible {
1968
1971
  <T>(value: T & string & number): boolean;
1969
1972
  // tslint:disable-next-line:ban-types (type guard doesn't seem to work correctly without the Function type)
1970
1973
  (value: ((...args: any[]) => any) | Function | string | boolean | number | null | undefined): value is never;
@@ -1976,7 +1979,7 @@ declare namespace _ {
1976
1979
  type LodashIsDate = (value: any) => value is Date;
1977
1980
  type LodashIsElement = (value: any) => boolean;
1978
1981
  type LodashIsEmpty = (value: any) => boolean;
1979
- interface LodashIsEqualWith {
1982
+ interface LodashIsEqualWith extends LodashConvertible {
1980
1983
  (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x1;
1981
1984
  (customizer: lodash.__, value: any): LodashIsEqualWith1x2;
1982
1985
  (customizer: lodash.IsEqualCustomizer, value: any): LodashIsEqualWith1x3;
@@ -2009,14 +2012,14 @@ declare namespace _ {
2009
2012
  type LodashIsInteger = (value: any) => boolean;
2010
2013
  type LodashIsLength = (value: any) => boolean;
2011
2014
  type LodashIsMap = (value: any) => value is Map<any, any>;
2012
- interface LodashIsMatch {
2015
+ interface LodashIsMatch extends LodashConvertible {
2013
2016
  (source: object): LodashIsMatch1x1;
2014
2017
  (source: lodash.__, object: object): LodashIsMatch1x2;
2015
2018
  (source: object, object: object): boolean;
2016
2019
  }
2017
2020
  type LodashIsMatch1x1 = (object: object) => boolean;
2018
2021
  type LodashIsMatch1x2 = (source: object) => boolean;
2019
- interface LodashIsMatchWith {
2022
+ interface LodashIsMatchWith extends LodashConvertible {
2020
2023
  (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x1;
2021
2024
  (customizer: lodash.__, source: object): LodashIsMatchWith1x2;
2022
2025
  (customizer: lodash.isMatchWithCustomizer, source: object): LodashIsMatchWith1x3;
@@ -2060,11 +2063,11 @@ declare namespace _ {
2060
2063
  type LodashIsUndefined = (value: any) => value is undefined;
2061
2064
  type LodashIsWeakMap = (value: any) => value is WeakMap<object, any>;
2062
2065
  type LodashIsWeakSet = (value: any) => value is WeakSet<object>;
2063
- interface LodashIteratee {
2066
+ interface LodashIteratee extends LodashConvertible {
2064
2067
  <TFunction extends (...args: any[]) => any>(func: TFunction): TFunction;
2065
2068
  (func: string | object): (...args: any[]) => any;
2066
2069
  }
2067
- interface LodashJoin {
2070
+ interface LodashJoin extends LodashConvertible {
2068
2071
  (separator: string): LodashJoin1x1;
2069
2072
  (separator: lodash.__, array: lodash.List<any> | null | undefined): LodashJoin1x2;
2070
2073
  (separator: string, array: lodash.List<any> | null | undefined): string;
@@ -2076,14 +2079,14 @@ declare namespace _ {
2076
2079
  type LodashKeys = (object: any) => string[];
2077
2080
  type LodashKeysIn = (object: any) => string[];
2078
2081
  type LodashLast = <T>(array: lodash.List<T> | null | undefined) => T | undefined;
2079
- interface LodashLastIndexOf {
2082
+ interface LodashLastIndexOf extends LodashConvertible {
2080
2083
  <T>(value: T): LodashLastIndexOf1x1<T>;
2081
2084
  <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashLastIndexOf1x2<T>;
2082
2085
  <T>(value: T, array: lodash.List<T> | null | undefined): number;
2083
2086
  }
2084
2087
  type LodashLastIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
2085
2088
  type LodashLastIndexOf1x2<T> = (value: T) => number;
2086
- interface LodashLastIndexOfFrom {
2089
+ interface LodashLastIndexOfFrom extends LodashConvertible {
2087
2090
  <T>(value: T): LodashLastIndexOfFrom1x1<T>;
2088
2091
  (value: lodash.__, fromIndex: true|number): LodashLastIndexOfFrom1x2;
2089
2092
  <T>(value: T, fromIndex: true|number): LodashLastIndexOfFrom1x3<T>;
@@ -2112,21 +2115,21 @@ declare namespace _ {
2112
2115
  type LodashLastIndexOfFrom1x6<T> = (value: T) => number;
2113
2116
  type LodashLowerCase = (string: string) => string;
2114
2117
  type LodashLowerFirst = (string: string) => string;
2115
- interface LodashLt {
2118
+ interface LodashLt extends LodashConvertible {
2116
2119
  (value: any): LodashLt1x1;
2117
2120
  (value: lodash.__, other: any): LodashLt1x2;
2118
2121
  (value: any, other: any): boolean;
2119
2122
  }
2120
2123
  type LodashLt1x1 = (other: any) => boolean;
2121
2124
  type LodashLt1x2 = (value: any) => boolean;
2122
- interface LodashLte {
2125
+ interface LodashLte extends LodashConvertible {
2123
2126
  (value: any): LodashLte1x1;
2124
2127
  (value: lodash.__, other: any): LodashLte1x2;
2125
2128
  (value: any, other: any): boolean;
2126
2129
  }
2127
2130
  type LodashLte1x1 = (other: any) => boolean;
2128
2131
  type LodashLte1x2 = (value: any) => boolean;
2129
- interface LodashMap {
2132
+ interface LodashMap extends LodashConvertible {
2130
2133
  <T, TResult>(iteratee: (value: T) => TResult): LodashMap1x1<T, TResult>;
2131
2134
  <T>(iteratee: lodash.__, collection: T[] | null | undefined): LodashMap1x2<T>;
2132
2135
  <T, TResult>(iteratee: (value: T) => TResult, collection: T[] | lodash.List<T> | null | undefined): TResult[];
@@ -2155,7 +2158,7 @@ declare namespace _ {
2155
2158
  }
2156
2159
  type LodashMap5x1 = <T>(collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => any[];
2157
2160
  type LodashMap6x1 = <T>(collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => boolean[];
2158
- interface LodashMapKeys {
2161
+ interface LodashMapKeys extends LodashConvertible {
2159
2162
  (iteratee: lodash.ValueIteratee<number>): LodashMapKeys1x1;
2160
2163
  <T>(iteratee: lodash.__, object: lodash.List<T> | null | undefined): LodashMapKeys1x2<T>;
2161
2164
  <T>(iteratee: lodash.ValueIteratee<number>, object: lodash.List<T> | null | undefined): lodash.Dictionary<T>;
@@ -2167,7 +2170,7 @@ declare namespace _ {
2167
2170
  type LodashMapKeys1x2<T> = (iteratee: lodash.ValueIteratee<number>) => lodash.Dictionary<T>;
2168
2171
  type LodashMapKeys2x1 = <T extends object>(object: T | null | undefined) => lodash.Dictionary<T[keyof T]>;
2169
2172
  type LodashMapKeys2x2<T> = (iteratee: lodash.ValueIteratee<string>) => lodash.Dictionary<T[keyof T]>;
2170
- interface LodashMapValues {
2173
+ interface LodashMapValues extends LodashConvertible {
2171
2174
  <T, TResult>(callback: (value: T) => TResult): LodashMapValues1x1<T, TResult>;
2172
2175
  <T>(callbackOrIterateeOrIterateeOrIteratee: lodash.__, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashMapValues1x2<T>;
2173
2176
  <T, TResult>(callback: (value: T) => TResult, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<TResult>;
@@ -2205,7 +2208,7 @@ declare namespace _ {
2205
2208
  <T>(obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<any>;
2206
2209
  <T extends object>(obj: T | null | undefined): { [P in keyof T]: any };
2207
2210
  }
2208
- interface LodashMatchesProperty {
2211
+ interface LodashMatchesProperty extends LodashConvertible {
2209
2212
  (path: lodash.PropertyPath): LodashMatchesProperty1x1;
2210
2213
  <T>(path: lodash.__, srcValue: T): LodashMatchesProperty1x2;
2211
2214
  <T>(path: lodash.PropertyPath, srcValue: T): (value: any) => boolean;
@@ -2213,7 +2216,7 @@ declare namespace _ {
2213
2216
  type LodashMatchesProperty1x1 = <T>(srcValue: T) => (value: any) => boolean;
2214
2217
  type LodashMatchesProperty1x2 = (path: lodash.PropertyPath) => (value: any) => boolean;
2215
2218
  type LodashMax = <T>(collection: lodash.List<T> | null | undefined) => T | undefined;
2216
- interface LodashMaxBy {
2219
+ interface LodashMaxBy extends LodashConvertible {
2217
2220
  <T>(iteratee: lodash.ValueIteratee<T>): LodashMaxBy1x1<T>;
2218
2221
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMaxBy1x2<T>;
2219
2222
  <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): T | undefined;
@@ -2221,7 +2224,7 @@ declare namespace _ {
2221
2224
  type LodashMaxBy1x1<T> = (collection: lodash.List<T> | null | undefined) => T | undefined;
2222
2225
  type LodashMaxBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T | undefined;
2223
2226
  type LodashMean = (collection: lodash.List<any> | null | undefined) => number;
2224
- interface LodashMeanBy {
2227
+ interface LodashMeanBy extends LodashConvertible {
2225
2228
  <T>(iteratee: lodash.ValueIteratee<T>): LodashMeanBy1x1<T>;
2226
2229
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMeanBy1x2<T>;
2227
2230
  <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): number;
@@ -2229,28 +2232,28 @@ declare namespace _ {
2229
2232
  type LodashMeanBy1x1<T> = (collection: lodash.List<T> | null | undefined) => number;
2230
2233
  type LodashMeanBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => number;
2231
2234
  type LodashMemoize = <T extends (...args: any[]) => any>(func: T) => T & lodash.MemoizedFunction;
2232
- interface LodashMerge {
2235
+ interface LodashMerge extends LodashConvertible {
2233
2236
  <TObject>(object: TObject): LodashMerge1x1<TObject>;
2234
2237
  <TSource>(object: lodash.__, source: TSource): LodashMerge1x2<TSource>;
2235
2238
  <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
2236
2239
  }
2237
2240
  type LodashMerge1x1<TObject> = <TSource>(source: TSource) => TObject & TSource;
2238
2241
  type LodashMerge1x2<TSource> = <TObject>(object: TObject) => TObject & TSource;
2239
- interface LodashMergeAll {
2242
+ interface LodashMergeAll extends LodashConvertible {
2240
2243
  <TObject, TSource>(object: [TObject, TSource]): TObject & TSource;
2241
2244
  <TObject, TSource1, TSource2>(object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2;
2242
2245
  <TObject, TSource1, TSource2, TSource3>(object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3;
2243
2246
  <TObject, TSource1, TSource2, TSource3, TSource4>(object: [TObject, TSource1, TSource2, TSource3, TSource4]): TObject & TSource1 & TSource2 & TSource3 & TSource4;
2244
2247
  (object: ReadonlyArray<any>): any;
2245
2248
  }
2246
- interface LodashMergeAllWith {
2249
+ interface LodashMergeAllWith extends LodashConvertible {
2247
2250
  (customizer: lodash.MergeWithCustomizer): LodashMergeAllWith1x1;
2248
2251
  (customizer: lodash.__, args: ReadonlyArray<any>): LodashMergeAllWith1x2;
2249
2252
  (customizer: lodash.MergeWithCustomizer, args: ReadonlyArray<any>): any;
2250
2253
  }
2251
2254
  type LodashMergeAllWith1x1 = (args: ReadonlyArray<any>) => any;
2252
2255
  type LodashMergeAllWith1x2 = (customizer: lodash.MergeWithCustomizer) => any;
2253
- interface LodashMergeWith {
2256
+ interface LodashMergeWith extends LodashConvertible {
2254
2257
  (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x1;
2255
2258
  <TObject>(customizer: lodash.__, object: TObject): LodashMergeWith1x2<TObject>;
2256
2259
  <TObject>(customizer: lodash.MergeWithCustomizer, object: TObject): LodashMergeWith1x3<TObject>;
@@ -2280,14 +2283,14 @@ declare namespace _ {
2280
2283
  type LodashMethod = (path: lodash.PropertyPath) => (object: any) => any;
2281
2284
  type LodashMethodOf = (object: object) => (path: lodash.PropertyPath) => any;
2282
2285
  type LodashMin = <T>(collection: lodash.List<T> | null | undefined) => T | undefined;
2283
- interface LodashMinBy {
2286
+ interface LodashMinBy extends LodashConvertible {
2284
2287
  <T>(iteratee: lodash.ValueIteratee<T>): LodashMinBy1x1<T>;
2285
2288
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMinBy1x2<T>;
2286
2289
  <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): T | undefined;
2287
2290
  }
2288
2291
  type LodashMinBy1x1<T> = (collection: lodash.List<T> | null | undefined) => T | undefined;
2289
2292
  type LodashMinBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T | undefined;
2290
- interface LodashMultiply {
2293
+ interface LodashMultiply extends LodashConvertible {
2291
2294
  (multiplier: number): LodashMultiply1x1;
2292
2295
  (multiplier: lodash.__, multiplicand: number): LodashMultiply1x2;
2293
2296
  (multiplier: number, multiplicand: number): number;
@@ -2297,7 +2300,7 @@ declare namespace _ {
2297
2300
  type LodashNoConflict = () => typeof _;
2298
2301
  type LodashNoop = (...args: any[]) => void;
2299
2302
  type LodashNow = () => number;
2300
- interface LodashNth {
2303
+ interface LodashNth extends LodashConvertible {
2301
2304
  (n: number): LodashNth1x1;
2302
2305
  <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashNth1x2<T>;
2303
2306
  <T>(n: number, array: lodash.List<T> | null | undefined): T | undefined;
@@ -2305,7 +2308,7 @@ declare namespace _ {
2305
2308
  type LodashNth1x1 = <T>(array: lodash.List<T> | null | undefined) => T | undefined;
2306
2309
  type LodashNth1x2<T> = (n: number) => T | undefined;
2307
2310
  type LodashNthArg = (n: number) => (...args: any[]) => any;
2308
- interface LodashOmit {
2311
+ interface LodashOmit extends LodashConvertible {
2309
2312
  (paths: lodash.Many<lodash.PropertyName>): LodashOmit1x1;
2310
2313
  <T extends lodash.AnyKindOfDictionary>(paths: lodash.__, object: T | null | undefined): LodashOmit1x2<T>;
2311
2314
  <T extends lodash.AnyKindOfDictionary>(paths: lodash.Many<lodash.PropertyName>, object: T | null | undefined): T;
@@ -2324,7 +2327,7 @@ declare namespace _ {
2324
2327
  <K extends keyof T>(paths: lodash.Many<K>): lodash.Omit<T, K>;
2325
2328
  (paths: lodash.Many<lodash.PropertyName>): lodash.PartialObject<T>;
2326
2329
  }
2327
- interface LodashOmitBy {
2330
+ interface LodashOmitBy extends LodashConvertible {
2328
2331
  <T>(predicate: lodash.ValueKeyIteratee<T>): LodashOmitBy1x1<T>;
2329
2332
  <T>(predicate: lodash.__, object: lodash.Dictionary<T> | null | undefined): LodashOmitBy1x2<T>;
2330
2333
  <T>(predicate: lodash.ValueKeyIteratee<T>, object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<T>;
@@ -2342,7 +2345,7 @@ declare namespace _ {
2342
2345
  type LodashOmitBy2x2<T> = (predicate: lodash.ValueKeyIteratee<T>) => lodash.NumericDictionary<T>;
2343
2346
  type LodashOmitBy3x2<T> = (predicate: lodash.ValueKeyIteratee<T[keyof T]>) => lodash.PartialObject<T>;
2344
2347
  type LodashOnce = <T extends (...args: any[]) => any>(func: T) => T;
2345
- interface LodashOrderBy {
2348
+ interface LodashOrderBy extends LodashConvertible {
2346
2349
  <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x1<T>;
2347
2350
  (iteratees: lodash.__, orders: lodash.Many<boolean|"asc"|"desc">): LodashOrderBy1x2;
2348
2351
  <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid>, orders: lodash.Many<boolean|"asc"|"desc">): LodashOrderBy1x3<T>;
@@ -2405,21 +2408,21 @@ declare namespace _ {
2405
2408
  type LodashOrderBy3x5<T> = (orders: lodash.Many<boolean|"asc"|"desc">) => Array<T[keyof T]>;
2406
2409
  type LodashOrderBy3x6<T> = (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T[keyof T]>>) => Array<T[keyof T]>;
2407
2410
  type LodashOrderBy4x5<T> = (orders: lodash.Many<boolean|"asc"|"desc">) => Array<T[keyof T]>;
2408
- interface LodashOverArgs {
2411
+ interface LodashOverArgs extends LodashConvertible {
2409
2412
  (func: (...args: any[]) => any): LodashOverArgs1x1;
2410
2413
  (func: lodash.__, transforms: lodash.Many<(...args: any[]) => any>): LodashOverArgs1x2;
2411
2414
  (func: (...args: any[]) => any, transforms: lodash.Many<(...args: any[]) => any>): (...args: any[]) => any;
2412
2415
  }
2413
2416
  type LodashOverArgs1x1 = (transforms: lodash.Many<(...args: any[]) => any>) => (...args: any[]) => any;
2414
2417
  type LodashOverArgs1x2 = (func: (...args: any[]) => any) => (...args: any[]) => any;
2415
- interface LodashPad {
2418
+ interface LodashPad extends LodashConvertible {
2416
2419
  (length: number): LodashPad1x1;
2417
2420
  (length: lodash.__, string: string): LodashPad1x2;
2418
2421
  (length: number, string: string): string;
2419
2422
  }
2420
2423
  type LodashPad1x1 = (string: string) => string;
2421
2424
  type LodashPad1x2 = (length: number) => string;
2422
- interface LodashPadChars {
2425
+ interface LodashPadChars extends LodashConvertible {
2423
2426
  (chars: string): LodashPadChars1x1;
2424
2427
  (chars: lodash.__, length: number): LodashPadChars1x2;
2425
2428
  (chars: string, length: number): LodashPadChars1x3;
@@ -2446,7 +2449,7 @@ declare namespace _ {
2446
2449
  }
2447
2450
  type LodashPadChars1x5 = (length: number) => string;
2448
2451
  type LodashPadChars1x6 = (chars: string) => string;
2449
- interface LodashPadCharsEnd {
2452
+ interface LodashPadCharsEnd extends LodashConvertible {
2450
2453
  (chars: string): LodashPadCharsEnd1x1;
2451
2454
  (chars: lodash.__, length: number): LodashPadCharsEnd1x2;
2452
2455
  (chars: string, length: number): LodashPadCharsEnd1x3;
@@ -2473,7 +2476,7 @@ declare namespace _ {
2473
2476
  }
2474
2477
  type LodashPadCharsEnd1x5 = (length: number) => string;
2475
2478
  type LodashPadCharsEnd1x6 = (chars: string) => string;
2476
- interface LodashPadCharsStart {
2479
+ interface LodashPadCharsStart extends LodashConvertible {
2477
2480
  (chars: string): LodashPadCharsStart1x1;
2478
2481
  (chars: lodash.__, length: number): LodashPadCharsStart1x2;
2479
2482
  (chars: string, length: number): LodashPadCharsStart1x3;
@@ -2500,28 +2503,28 @@ declare namespace _ {
2500
2503
  }
2501
2504
  type LodashPadCharsStart1x5 = (length: number) => string;
2502
2505
  type LodashPadCharsStart1x6 = (chars: string) => string;
2503
- interface LodashPadEnd {
2506
+ interface LodashPadEnd extends LodashConvertible {
2504
2507
  (length: number): LodashPadEnd1x1;
2505
2508
  (length: lodash.__, string: string): LodashPadEnd1x2;
2506
2509
  (length: number, string: string): string;
2507
2510
  }
2508
2511
  type LodashPadEnd1x1 = (string: string) => string;
2509
2512
  type LodashPadEnd1x2 = (length: number) => string;
2510
- interface LodashPadStart {
2513
+ interface LodashPadStart extends LodashConvertible {
2511
2514
  (length: number): LodashPadStart1x1;
2512
2515
  (length: lodash.__, string: string): LodashPadStart1x2;
2513
2516
  (length: number, string: string): string;
2514
2517
  }
2515
2518
  type LodashPadStart1x1 = (string: string) => string;
2516
2519
  type LodashPadStart1x2 = (length: number) => string;
2517
- interface LodashParseInt {
2520
+ interface LodashParseInt extends LodashConvertible {
2518
2521
  (radix: number): LodashParseInt1x1;
2519
2522
  (radix: lodash.__, string: string): LodashParseInt1x2;
2520
2523
  (radix: number, string: string): number;
2521
2524
  }
2522
2525
  type LodashParseInt1x1 = (string: string) => number;
2523
2526
  type LodashParseInt1x2 = (radix: number) => number;
2524
- interface LodashPartial {
2527
+ interface LodashPartial extends LodashConvertible {
2525
2528
  <T1, R>(func: lodash.Function1<T1, R>): LodashPartial1x1<T1, R>;
2526
2529
  <T1>(func: lodash.__, arg1: [T1]): LodashPartial1x2<T1>;
2527
2530
  <T1, R>(func: lodash.Function1<T1, R>, arg1: [T1]): lodash.Function0<R>;
@@ -2646,7 +2649,7 @@ declare namespace _ {
2646
2649
  type LodashPartial26x2<T1, T2, T3, T4> = <R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function0< R>;
2647
2650
  type LodashPartial27x1 = (args: ReadonlyArray<any>) => (...args: any[]) => any;
2648
2651
  type LodashPartial27x2 = (func: (...args: any[]) => any) => (...args: any[]) => any;
2649
- interface LodashPartialRight {
2652
+ interface LodashPartialRight extends LodashConvertible {
2650
2653
  <T1, R>(func: lodash.Function1<T1, R>): LodashPartialRight1x1<T1, R>;
2651
2654
  <T1>(func: lodash.__, arg1: [T1]): LodashPartialRight1x2<T1>;
2652
2655
  <T1, R>(func: lodash.Function1<T1, R>, arg1: [T1]): lodash.Function0<R>;
@@ -2768,7 +2771,7 @@ declare namespace _ {
2768
2771
  type LodashPartialRight26x2<T1, T2, T3, T4> = <R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function0< R>;
2769
2772
  type LodashPartialRight27x1 = (args: ReadonlyArray<any>) => (...args: any[]) => any;
2770
2773
  type LodashPartialRight27x2 = (func: (...args: any[]) => any) => (...args: any[]) => any;
2771
- interface LodashPartition {
2774
+ interface LodashPartition extends LodashConvertible {
2772
2775
  <T, U extends T>(callback: lodash.ValueIteratorTypeGuard<T, U>): LodashPartition1x1<T, U>;
2773
2776
  <T>(callback: lodash.__, collection: lodash.List<T> | null | undefined): LodashPartition1x2<T>;
2774
2777
  <T, U extends T>(callback: lodash.ValueIteratorTypeGuard<T, U>, collection: lodash.List<T> | null | undefined): [U[], Array<Exclude<T, U>>];
@@ -2784,7 +2787,7 @@ declare namespace _ {
2784
2787
  }
2785
2788
  type LodashPartition2x1<T> = (collection: lodash.List<T> | object | null | undefined) => [T[], T[]];
2786
2789
  type LodashPartition3x2<T> = (callback: lodash.ValueIteratee<T[keyof T]>) => [Array<T[keyof T]>, Array<T[keyof T]>];
2787
- interface LodashPath {
2790
+ interface LodashPath extends LodashConvertible {
2788
2791
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashPath1x1<TObject, TKey>;
2789
2792
  <TObject extends object>(path: lodash.__, object: TObject): LodashPath1x2<TObject>;
2790
2793
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
@@ -2833,7 +2836,7 @@ declare namespace _ {
2833
2836
  }
2834
2837
  type LodashPath8x2 = (path: lodash.PropertyPath) => undefined;
2835
2838
  type LodashPath9x2 = (path: lodash.PropertyPath) => any;
2836
- interface LodashPathOr {
2839
+ interface LodashPathOr extends LodashConvertible {
2837
2840
  <TDefault>(defaultValue: TDefault): LodashPathOr1x1<TDefault>;
2838
2841
  <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashPathOr1x2<TObject, TKey>;
2839
2842
  <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): LodashPathOr1x3<TObject, TKey, TDefault>;
@@ -2976,7 +2979,7 @@ declare namespace _ {
2976
2979
  }
2977
2980
  type LodashPathOr7x5 = (path: lodash.PropertyPath) => any;
2978
2981
  type LodashPathOr7x6 = (defaultValue: any) => any;
2979
- interface LodashPick {
2982
+ interface LodashPick extends LodashConvertible {
2980
2983
  <T extends object, U extends keyof T>(props: lodash.Many<U>): LodashPick1x1<T, U>;
2981
2984
  <T extends object>(props: lodash.__, object: T): LodashPick1x2<T>;
2982
2985
  <T extends object, U extends keyof T>(props: lodash.Many<U>, object: T): Pick<T, U>;
@@ -2988,7 +2991,7 @@ declare namespace _ {
2988
2991
  type LodashPick1x2<T> = <U extends keyof T>(props: lodash.Many<U>) => Pick<T, U>;
2989
2992
  type LodashPick2x1 = <T>(object: T | null | undefined) => lodash.PartialDeep<T>;
2990
2993
  type LodashPick2x2<T> = (props: lodash.PropertyPath) => lodash.PartialDeep<T>;
2991
- interface LodashPickBy {
2994
+ interface LodashPickBy extends LodashConvertible {
2992
2995
  <T, S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>): LodashPickBy1x1<T, S>;
2993
2996
  <T>(predicate: lodash.__, object: lodash.Dictionary<T> | null | undefined): LodashPickBy1x2<T>;
2994
2997
  <T, S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>, object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<S>;
@@ -3018,7 +3021,7 @@ declare namespace _ {
3018
3021
  <T1 extends object>(object: T1 | null | undefined): lodash.PartialObject<T1>;
3019
3022
  }
3020
3023
  type LodashPickBy5x2<T> = (predicate: lodash.ValueKeyIteratee<T[keyof T]>) => lodash.PartialObject<T>;
3021
- interface LodashProp {
3024
+ interface LodashProp extends LodashConvertible {
3022
3025
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashProp1x1<TObject, TKey>;
3023
3026
  <TObject extends object>(path: lodash.__, object: TObject): LodashProp1x2<TObject>;
3024
3027
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
@@ -3067,7 +3070,7 @@ declare namespace _ {
3067
3070
  }
3068
3071
  type LodashProp8x2 = (path: lodash.PropertyPath) => undefined;
3069
3072
  type LodashProp9x2 = (path: lodash.PropertyPath) => any;
3070
- interface LodashProperty {
3073
+ interface LodashProperty extends LodashConvertible {
3071
3074
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashProperty1x1<TObject, TKey>;
3072
3075
  <TObject extends object>(path: lodash.__, object: TObject): LodashProperty1x2<TObject>;
3073
3076
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
@@ -3116,7 +3119,7 @@ declare namespace _ {
3116
3119
  }
3117
3120
  type LodashProperty8x2 = (path: lodash.PropertyPath) => undefined;
3118
3121
  type LodashProperty9x2 = (path: lodash.PropertyPath) => any;
3119
- interface LodashPropertyOf {
3122
+ interface LodashPropertyOf extends LodashConvertible {
3120
3123
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashPropertyOf1x1<TObject, TKey>;
3121
3124
  <TObject extends object>(path: lodash.__, object: TObject): LodashPropertyOf1x2<TObject>;
3122
3125
  <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
@@ -3165,7 +3168,7 @@ declare namespace _ {
3165
3168
  }
3166
3169
  type LodashPropertyOf8x2 = (path: lodash.PropertyPath) => undefined;
3167
3170
  type LodashPropertyOf9x2 = (path: lodash.PropertyPath) => any;
3168
- interface LodashPropOr {
3171
+ interface LodashPropOr extends LodashConvertible {
3169
3172
  <TDefault>(defaultValue: TDefault): LodashPropOr1x1<TDefault>;
3170
3173
  <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashPropOr1x2<TObject, TKey>;
3171
3174
  <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): LodashPropOr1x3<TObject, TKey, TDefault>;
@@ -3308,7 +3311,7 @@ declare namespace _ {
3308
3311
  }
3309
3312
  type LodashPropOr7x5 = (path: lodash.PropertyPath) => any;
3310
3313
  type LodashPropOr7x6 = (defaultValue: any) => any;
3311
- interface LodashPull {
3314
+ interface LodashPull extends LodashConvertible {
3312
3315
  <T>(values: T): LodashPull1x1<T>;
3313
3316
  <T>(values: lodash.__, array: ReadonlyArray<T>): LodashPull1x2<T>;
3314
3317
  <T>(values: T, array: ReadonlyArray<T>): T[];
@@ -3321,7 +3324,7 @@ declare namespace _ {
3321
3324
  }
3322
3325
  type LodashPull1x2<T> = (values: T) => T[];
3323
3326
  type LodashPull2x2<T> = (values: T) => lodash.List<T>;
3324
- interface LodashPullAll {
3327
+ interface LodashPullAll extends LodashConvertible {
3325
3328
  <T>(values: lodash.List<T>): LodashPullAll1x1<T>;
3326
3329
  <T>(values: lodash.__, array: ReadonlyArray<T>): LodashPullAll1x2<T>;
3327
3330
  <T>(values: lodash.List<T>, array: ReadonlyArray<T>): T[];
@@ -3334,7 +3337,7 @@ declare namespace _ {
3334
3337
  }
3335
3338
  type LodashPullAll1x2<T> = (values: lodash.List<T>) => T[];
3336
3339
  type LodashPullAll2x2<T> = (values: lodash.List<T>) => lodash.List<T>;
3337
- interface LodashPullAllBy {
3340
+ interface LodashPullAllBy extends LodashConvertible {
3338
3341
  <T>(iteratee: lodash.ValueIteratee<T>): LodashPullAllBy1x1<T>;
3339
3342
  <T>(iteratee: lodash.__, values: lodash.List<T>): LodashPullAllBy1x2<T>;
3340
3343
  <T>(iteratee: lodash.ValueIteratee<T>, values: lodash.List<T>): LodashPullAllBy1x3<T>;
@@ -3422,7 +3425,7 @@ declare namespace _ {
3422
3425
  }
3423
3426
  type LodashPullAllBy4x5<T1, T2> = (values: lodash.List<T2>) => lodash.List<T1>;
3424
3427
  type LodashPullAllBy4x6<T1, T2> = (iteratee: lodash.ValueIteratee<T1 | T2>) => lodash.List<T1>;
3425
- interface LodashPullAllWith {
3428
+ interface LodashPullAllWith extends LodashConvertible {
3426
3429
  <T>(comparator: lodash.Comparator<T>): LodashPullAllWith1x1<T>;
3427
3430
  <T>(comparator: lodash.__, values: lodash.List<T>): LodashPullAllWith1x2<T>;
3428
3431
  <T>(comparator: lodash.Comparator<T>, values: lodash.List<T>): LodashPullAllWith1x3<T>;
@@ -3510,7 +3513,7 @@ declare namespace _ {
3510
3513
  }
3511
3514
  type LodashPullAllWith4x5<T1, T2> = (values: lodash.List<T2>) => lodash.List<T1>;
3512
3515
  type LodashPullAllWith4x6<T1, T2> = (comparator: lodash.Comparator2<T1, T2>) => lodash.List<T1>;
3513
- interface LodashPullAt {
3516
+ interface LodashPullAt extends LodashConvertible {
3514
3517
  (indexes: lodash.Many<number>): LodashPullAt1x1;
3515
3518
  <T>(indexes: lodash.__, array: ReadonlyArray<T>): LodashPullAt1x2<T>;
3516
3519
  <T>(indexes: lodash.Many<number>, array: ReadonlyArray<T>): T[];
@@ -3523,7 +3526,7 @@ declare namespace _ {
3523
3526
  }
3524
3527
  type LodashPullAt1x2<T> = (indexes: lodash.Many<number>) => T[];
3525
3528
  type LodashPullAt2x2<T> = (indexes: lodash.Many<number>) => lodash.List<T>;
3526
- interface LodashRandom {
3529
+ interface LodashRandom extends LodashConvertible {
3527
3530
  (maxOrMin: number): LodashRandom1x1;
3528
3531
  (max: lodash.__, floating: boolean): LodashRandom1x2;
3529
3532
  (maxOrMin: number, floatingOrMax: boolean | number): number;
@@ -3532,21 +3535,21 @@ declare namespace _ {
3532
3535
  type LodashRandom1x1 = (floatingOrMax: boolean | number) => number;
3533
3536
  type LodashRandom1x2 = (max: number) => number;
3534
3537
  type LodashRandom2x2 = (min: number) => number;
3535
- interface LodashRange {
3538
+ interface LodashRange extends LodashConvertible {
3536
3539
  (start: number): LodashRange1x1;
3537
3540
  (start: lodash.__, end: number): LodashRange1x2;
3538
3541
  (start: number, end: number): number[];
3539
3542
  }
3540
3543
  type LodashRange1x1 = (end: number) => number[];
3541
3544
  type LodashRange1x2 = (start: number) => number[];
3542
- interface LodashRangeRight {
3545
+ interface LodashRangeRight extends LodashConvertible {
3543
3546
  (start: number): LodashRangeRight1x1;
3544
3547
  (start: lodash.__, end: number): LodashRangeRight1x2;
3545
3548
  (start: number, end: number): number[];
3546
3549
  }
3547
3550
  type LodashRangeRight1x1 = (end: number) => number[];
3548
3551
  type LodashRangeRight1x2 = (start: number) => number[];
3549
- interface LodashRangeStep {
3552
+ interface LodashRangeStep extends LodashConvertible {
3550
3553
  (start: number): LodashRangeStep1x1;
3551
3554
  (start: lodash.__, end: number): LodashRangeStep1x2;
3552
3555
  (start: number, end: number): LodashRangeStep1x3;
@@ -3573,7 +3576,7 @@ declare namespace _ {
3573
3576
  }
3574
3577
  type LodashRangeStep1x5 = (end: number) => number[];
3575
3578
  type LodashRangeStep1x6 = (start: number) => number[];
3576
- interface LodashRangeStepRight {
3579
+ interface LodashRangeStepRight extends LodashConvertible {
3577
3580
  (start: number): LodashRangeStepRight1x1;
3578
3581
  (start: lodash.__, end: number): LodashRangeStepRight1x2;
3579
3582
  (start: number, end: number): LodashRangeStepRight1x3;
@@ -3600,14 +3603,14 @@ declare namespace _ {
3600
3603
  }
3601
3604
  type LodashRangeStepRight1x5 = (end: number) => number[];
3602
3605
  type LodashRangeStepRight1x6 = (start: number) => number[];
3603
- interface LodashRearg {
3606
+ interface LodashRearg extends LodashConvertible {
3604
3607
  (indexes: lodash.Many<number>): LodashRearg1x1;
3605
3608
  (indexes: lodash.__, func: (...args: any[]) => any): LodashRearg1x2;
3606
3609
  (indexes: lodash.Many<number>, func: (...args: any[]) => any): (...args: any[]) => any;
3607
3610
  }
3608
3611
  type LodashRearg1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any;
3609
3612
  type LodashRearg1x2 = (indexes: lodash.Many<number>) => (...args: any[]) => any;
3610
- interface LodashReduce {
3613
+ interface LodashReduce extends LodashConvertible {
3611
3614
  <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>): LodashReduce1x1<T, TResult>;
3612
3615
  <TResult>(callback: lodash.__, accumulator: TResult): LodashReduce1x2<TResult>;
3613
3616
  <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: TResult): LodashReduce1x3<T, TResult>;
@@ -3668,7 +3671,7 @@ declare namespace _ {
3668
3671
  }
3669
3672
  type LodashReduce3x5<TResult> = (accumulator: TResult) => TResult;
3670
3673
  type LodashReduce3x6<T, TResult> = (callback: lodash.MemoIteratorCapped<T[keyof T], TResult>) => TResult;
3671
- interface LodashReduceRight {
3674
+ interface LodashReduceRight extends LodashConvertible {
3672
3675
  <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>): LodashReduceRight1x1<T, TResult>;
3673
3676
  <TResult>(callback: lodash.__, accumulator: TResult): LodashReduceRight1x2<TResult>;
3674
3677
  <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: TResult): LodashReduceRight1x3<T, TResult>;
@@ -3729,7 +3732,7 @@ declare namespace _ {
3729
3732
  }
3730
3733
  type LodashReduceRight3x5<TResult> = (accumulator: TResult) => TResult;
3731
3734
  type LodashReduceRight3x6<T, TResult> = (callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>) => TResult;
3732
- interface LodashReject {
3735
+ interface LodashReject extends LodashConvertible {
3733
3736
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashReject1x1<T>;
3734
3737
  <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashReject1x2<T>;
3735
3738
  <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, collection: lodash.List<T> | null | undefined): T[];
@@ -3739,21 +3742,21 @@ declare namespace _ {
3739
3742
  type LodashReject1x1<T> = (collection: lodash.List<T> | object | null | undefined) => T[];
3740
3743
  type LodashReject1x2<T> = (predicate: lodash.ValueIterateeCustom<T, boolean>) => T[];
3741
3744
  type LodashReject2x2<T> = (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>) => Array<T[keyof T]>;
3742
- interface LodashRemove {
3745
+ interface LodashRemove extends LodashConvertible {
3743
3746
  <T>(predicate: lodash.ValueIteratee<T>): LodashRemove1x1<T>;
3744
3747
  <T>(predicate: lodash.__, array: lodash.List<T>): LodashRemove1x2<T>;
3745
3748
  <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T>): T[];
3746
3749
  }
3747
3750
  type LodashRemove1x1<T> = (array: lodash.List<T>) => T[];
3748
3751
  type LodashRemove1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
3749
- interface LodashRepeat {
3752
+ interface LodashRepeat extends LodashConvertible {
3750
3753
  (n: number): LodashRepeat1x1;
3751
3754
  (n: lodash.__, string: string): LodashRepeat1x2;
3752
3755
  (n: number, string: string): string;
3753
3756
  }
3754
3757
  type LodashRepeat1x1 = (string: string) => string;
3755
3758
  type LodashRepeat1x2 = (n: number) => string;
3756
- interface LodashReplace {
3759
+ interface LodashReplace extends LodashConvertible {
3757
3760
  (pattern: RegExp | string): LodashReplace1x1;
3758
3761
  (pattern: lodash.__, replacement: lodash.ReplaceFunction | string): LodashReplace1x2;
3759
3762
  (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string): LodashReplace1x3;
@@ -3781,14 +3784,14 @@ declare namespace _ {
3781
3784
  type LodashReplace1x5 = (replacement: lodash.ReplaceFunction | string) => string;
3782
3785
  type LodashReplace1x6 = (pattern: RegExp | string) => string;
3783
3786
  type LodashRest = (func: (...args: any[]) => any) => (...args: any[]) => any;
3784
- interface LodashRestFrom {
3787
+ interface LodashRestFrom extends LodashConvertible {
3785
3788
  (start: number): LodashRestFrom1x1;
3786
3789
  (start: lodash.__, func: (...args: any[]) => any): LodashRestFrom1x2;
3787
3790
  (start: number, func: (...args: any[]) => any): (...args: any[]) => any;
3788
3791
  }
3789
3792
  type LodashRestFrom1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any;
3790
3793
  type LodashRestFrom1x2 = (start: number) => (...args: any[]) => any;
3791
- interface LodashResult {
3794
+ interface LodashResult extends LodashConvertible {
3792
3795
  (path: lodash.PropertyPath): LodashResult1x1;
3793
3796
  (path: lodash.__, object: any): LodashResult1x2;
3794
3797
  <TResult>(path: lodash.PropertyPath, object: any): TResult;
@@ -3798,11 +3801,11 @@ declare namespace _ {
3798
3801
  type LodashReverse = <TList extends lodash.List<any>>(array: TList) => TList;
3799
3802
  type LodashRound = (n: number) => number;
3800
3803
  type LodashRunInContext = (context: object) => lodash.LoDashStatic;
3801
- interface LodashSample {
3804
+ interface LodashSample extends LodashConvertible {
3802
3805
  <T>(collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T | undefined;
3803
3806
  <T extends object>(collection: T | null | undefined): T[keyof T] | undefined;
3804
3807
  }
3805
- interface LodashSampleSize {
3808
+ interface LodashSampleSize extends LodashConvertible {
3806
3809
  (n: number): LodashSampleSize1x1;
3807
3810
  <T>(n: lodash.__, collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashSampleSize1x2<T>;
3808
3811
  <T>(n: number, collection: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T[];
@@ -3815,7 +3818,7 @@ declare namespace _ {
3815
3818
  }
3816
3819
  type LodashSampleSize1x2<T> = (n: number) => T[];
3817
3820
  type LodashSampleSize2x2<T> = (n: number) => Array<T[keyof T]>;
3818
- interface LodashSetWith {
3821
+ interface LodashSetWith extends LodashConvertible {
3819
3822
  <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x1<T>;
3820
3823
  (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x2;
3821
3824
  <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashSetWith1x3<T>;
@@ -3902,12 +3905,12 @@ declare namespace _ {
3902
3905
  }
3903
3906
  type LodashSetWith1x13<T> = (path: lodash.PropertyPath) => T;
3904
3907
  type LodashSetWith1x14<T> = (customizer: lodash.SetWithCustomizer<T>) => T;
3905
- interface LodashShuffle {
3908
+ interface LodashShuffle extends LodashConvertible {
3906
3909
  <T>(collection: lodash.List<T> | null | undefined): T[];
3907
3910
  <T extends object>(collection: T | null | undefined): Array<T[keyof T]>;
3908
3911
  }
3909
3912
  type LodashSize = (collection: object | string | null | undefined) => number;
3910
- interface LodashSlice {
3913
+ interface LodashSlice extends LodashConvertible {
3911
3914
  (start: number): LodashSlice1x1;
3912
3915
  (start: lodash.__, end: number): LodashSlice1x2;
3913
3916
  (start: number, end: number): LodashSlice1x3;
@@ -3935,7 +3938,7 @@ declare namespace _ {
3935
3938
  type LodashSlice1x5<T> = (end: number) => T[];
3936
3939
  type LodashSlice1x6<T> = (start: number) => T[];
3937
3940
  type LodashSnakeCase = (string: string) => string;
3938
- interface LodashSortBy {
3941
+ interface LodashSortBy extends LodashConvertible {
3939
3942
  <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>): LodashSortBy1x1<T>;
3940
3943
  <T>(iteratees: lodash.__, collection: lodash.List<T> | null | undefined): LodashSortBy1x2<T>;
3941
3944
  <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>, collection: lodash.List<T> | null | undefined): T[];
@@ -3945,14 +3948,14 @@ declare namespace _ {
3945
3948
  type LodashSortBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => T[];
3946
3949
  type LodashSortBy1x2<T> = (iteratees: lodash.Many<lodash.ValueIteratee<T>>) => T[];
3947
3950
  type LodashSortBy2x2<T> = (iteratees: lodash.Many<lodash.ValueIteratee<T[keyof T]>>) => Array<T[keyof T]>;
3948
- interface LodashSortedIndex {
3951
+ interface LodashSortedIndex extends LodashConvertible {
3949
3952
  <T>(value: T): LodashSortedIndex1x1<T>;
3950
3953
  <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndex1x2<T>;
3951
3954
  <T>(value: T, array: lodash.List<T> | null | undefined): number;
3952
3955
  }
3953
3956
  type LodashSortedIndex1x1<T> = (array: lodash.List<T> | null | undefined) => number;
3954
3957
  type LodashSortedIndex1x2<T> = (value: T) => number;
3955
- interface LodashSortedIndexBy {
3958
+ interface LodashSortedIndexBy extends LodashConvertible {
3956
3959
  <T>(iteratee: lodash.ValueIteratee<T>): LodashSortedIndexBy1x1<T>;
3957
3960
  <T>(iteratee: lodash.__, value: T): LodashSortedIndexBy1x2<T>;
3958
3961
  <T>(iteratee: lodash.ValueIteratee<T>, value: T): LodashSortedIndexBy1x3<T>;
@@ -3979,21 +3982,21 @@ declare namespace _ {
3979
3982
  }
3980
3983
  type LodashSortedIndexBy1x5<T> = (value: T) => number;
3981
3984
  type LodashSortedIndexBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => number;
3982
- interface LodashSortedIndexOf {
3985
+ interface LodashSortedIndexOf extends LodashConvertible {
3983
3986
  <T>(value: T): LodashSortedIndexOf1x1<T>;
3984
3987
  <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndexOf1x2<T>;
3985
3988
  <T>(value: T, array: lodash.List<T> | null | undefined): number;
3986
3989
  }
3987
3990
  type LodashSortedIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
3988
3991
  type LodashSortedIndexOf1x2<T> = (value: T) => number;
3989
- interface LodashSortedLastIndex {
3992
+ interface LodashSortedLastIndex extends LodashConvertible {
3990
3993
  <T>(value: T): LodashSortedLastIndex1x1<T>;
3991
3994
  <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndex1x2<T>;
3992
3995
  <T>(value: T, array: lodash.List<T> | null | undefined): number;
3993
3996
  }
3994
3997
  type LodashSortedLastIndex1x1<T> = (array: lodash.List<T> | null | undefined) => number;
3995
3998
  type LodashSortedLastIndex1x2<T> = (value: T) => number;
3996
- interface LodashSortedLastIndexBy {
3999
+ interface LodashSortedLastIndexBy extends LodashConvertible {
3997
4000
  <T>(iteratee: lodash.ValueIteratee<T>): LodashSortedLastIndexBy1x1<T>;
3998
4001
  <T>(iteratee: lodash.__, value: T): LodashSortedLastIndexBy1x2<T>;
3999
4002
  <T>(iteratee: lodash.ValueIteratee<T>, value: T): LodashSortedLastIndexBy1x3<T>;
@@ -4020,7 +4023,7 @@ declare namespace _ {
4020
4023
  }
4021
4024
  type LodashSortedLastIndexBy1x5<T> = (value: T) => number;
4022
4025
  type LodashSortedLastIndexBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => number;
4023
- interface LodashSortedLastIndexOf {
4026
+ interface LodashSortedLastIndexOf extends LodashConvertible {
4024
4027
  <T>(value: T): LodashSortedLastIndexOf1x1<T>;
4025
4028
  <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndexOf1x2<T>;
4026
4029
  <T>(value: T, array: lodash.List<T> | null | undefined): number;
@@ -4028,14 +4031,14 @@ declare namespace _ {
4028
4031
  type LodashSortedLastIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
4029
4032
  type LodashSortedLastIndexOf1x2<T> = (value: T) => number;
4030
4033
  type LodashSortedUniq = <T>(array: lodash.List<T> | null | undefined) => T[];
4031
- interface LodashSortedUniqBy {
4034
+ interface LodashSortedUniqBy extends LodashConvertible {
4032
4035
  <T>(iteratee: lodash.ValueIteratee<T>): LodashSortedUniqBy1x1<T>;
4033
4036
  <T>(iteratee: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedUniqBy1x2<T>;
4034
4037
  <T>(iteratee: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
4035
4038
  }
4036
4039
  type LodashSortedUniqBy1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
4037
4040
  type LodashSortedUniqBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
4038
- interface LodashSplit {
4041
+ interface LodashSplit extends LodashConvertible {
4039
4042
  (separator: RegExp|string): LodashSplit1x1;
4040
4043
  (separator: lodash.__, string: string): LodashSplit1x2;
4041
4044
  (separator: RegExp|string, string: string): string[];
@@ -4043,7 +4046,7 @@ declare namespace _ {
4043
4046
  type LodashSplit1x1 = (string: string) => string[];
4044
4047
  type LodashSplit1x2 = (separator: RegExp|string) => string[];
4045
4048
  type LodashSpread = <TResult>(func: (...args: any[]) => TResult) => (...args: any[]) => TResult;
4046
- interface LodashSpreadFrom {
4049
+ interface LodashSpreadFrom extends LodashConvertible {
4047
4050
  (start: number): LodashSpreadFrom1x1;
4048
4051
  <TResult>(start: lodash.__, func: (...args: any[]) => TResult): LodashSpreadFrom1x2<TResult>;
4049
4052
  <TResult>(start: number, func: (...args: any[]) => TResult): (...args: any[]) => TResult;
@@ -4051,7 +4054,7 @@ declare namespace _ {
4051
4054
  type LodashSpreadFrom1x1 = <TResult>(func: (...args: any[]) => TResult) => (...args: any[]) => TResult;
4052
4055
  type LodashSpreadFrom1x2<TResult> = (start: number) => (...args: any[]) => TResult;
4053
4056
  type LodashStartCase = (string: string) => string;
4054
- interface LodashStartsWith {
4057
+ interface LodashStartsWith extends LodashConvertible {
4055
4058
  (target: string): LodashStartsWith1x1;
4056
4059
  (target: lodash.__, string: string): LodashStartsWith1x2;
4057
4060
  (target: string, string: string): boolean;
@@ -4062,7 +4065,7 @@ declare namespace _ {
4062
4065
  type LodashStubObject = () => any;
4063
4066
  type LodashStubString = () => string;
4064
4067
  type LodashStubTrue = () => true;
4065
- interface LodashSubtract {
4068
+ interface LodashSubtract extends LodashConvertible {
4066
4069
  (minuend: number): LodashSubtract1x1;
4067
4070
  (minuend: lodash.__, subtrahend: number): LodashSubtract1x2;
4068
4071
  (minuend: number, subtrahend: number): number;
@@ -4070,21 +4073,21 @@ declare namespace _ {
4070
4073
  type LodashSubtract1x1 = (subtrahend: number) => number;
4071
4074
  type LodashSubtract1x2 = (minuend: number) => number;
4072
4075
  type LodashSum = (collection: lodash.List<any> | null | undefined) => number;
4073
- interface LodashSumBy {
4076
+ interface LodashSumBy extends LodashConvertible {
4074
4077
  <T>(iteratee: ((value: T) => number) | string): LodashSumBy1x1<T>;
4075
4078
  <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashSumBy1x2<T>;
4076
4079
  <T>(iteratee: ((value: T) => number) | string, collection: lodash.List<T> | null | undefined): number;
4077
4080
  }
4078
4081
  type LodashSumBy1x1<T> = (collection: lodash.List<T> | null | undefined) => number;
4079
4082
  type LodashSumBy1x2<T> = (iteratee: ((value: T) => number) | string) => number;
4080
- interface LodashXor {
4083
+ interface LodashXor extends LodashConvertible {
4081
4084
  <T>(arrays2: lodash.List<T> | null | undefined): LodashXor1x1<T>;
4082
4085
  <T>(arrays2: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXor1x2<T>;
4083
4086
  <T>(arrays2: lodash.List<T> | null | undefined, arrays: lodash.List<T> | null | undefined): T[];
4084
4087
  }
4085
4088
  type LodashXor1x1<T> = (arrays: lodash.List<T> | null | undefined) => T[];
4086
4089
  type LodashXor1x2<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
4087
- interface LodashXorBy {
4090
+ interface LodashXorBy extends LodashConvertible {
4088
4091
  <T>(iteratee: lodash.ValueIteratee<T>): LodashXorBy1x1<T>;
4089
4092
  <T>(iteratee: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXorBy1x2<T>;
4090
4093
  <T>(iteratee: lodash.ValueIteratee<T>, arrays: lodash.List<T> | null | undefined): LodashXorBy1x3<T>;
@@ -4111,7 +4114,7 @@ declare namespace _ {
4111
4114
  }
4112
4115
  type LodashXorBy1x5<T> = (arrays: lodash.List<T> | null | undefined) => T[];
4113
4116
  type LodashXorBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
4114
- interface LodashXorWith {
4117
+ interface LodashXorWith extends LodashConvertible {
4115
4118
  <T>(comparator: lodash.Comparator<T>): LodashXorWith1x1<T>;
4116
4119
  <T>(comparator: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXorWith1x2<T>;
4117
4120
  <T>(comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined): LodashXorWith1x3<T>;
@@ -4139,35 +4142,35 @@ declare namespace _ {
4139
4142
  type LodashXorWith1x5<T> = (arrays: lodash.List<T> | null | undefined) => T[];
4140
4143
  type LodashXorWith1x6<T> = (comparator: lodash.Comparator<T>) => T[];
4141
4144
  type LodashTail = <T>(array: lodash.List<T> | null | undefined) => T[];
4142
- interface LodashTake {
4145
+ interface LodashTake extends LodashConvertible {
4143
4146
  (n: number): LodashTake1x1;
4144
4147
  <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashTake1x2<T>;
4145
4148
  <T>(n: number, array: lodash.List<T> | null | undefined): T[];
4146
4149
  }
4147
4150
  type LodashTake1x1 = <T>(array: lodash.List<T> | null | undefined) => T[];
4148
4151
  type LodashTake1x2<T> = (n: number) => T[];
4149
- interface LodashTakeRight {
4152
+ interface LodashTakeRight extends LodashConvertible {
4150
4153
  (n: number): LodashTakeRight1x1;
4151
4154
  <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashTakeRight1x2<T>;
4152
4155
  <T>(n: number, array: lodash.List<T> | null | undefined): T[];
4153
4156
  }
4154
4157
  type LodashTakeRight1x1 = <T>(array: lodash.List<T> | null | undefined) => T[];
4155
4158
  type LodashTakeRight1x2<T> = (n: number) => T[];
4156
- interface LodashTakeRightWhile {
4159
+ interface LodashTakeRightWhile extends LodashConvertible {
4157
4160
  <T>(predicate: lodash.ValueIteratee<T>): LodashTakeRightWhile1x1<T>;
4158
4161
  <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashTakeRightWhile1x2<T>;
4159
4162
  <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
4160
4163
  }
4161
4164
  type LodashTakeRightWhile1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
4162
4165
  type LodashTakeRightWhile1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
4163
- interface LodashTakeWhile {
4166
+ interface LodashTakeWhile extends LodashConvertible {
4164
4167
  <T>(predicate: lodash.ValueIteratee<T>): LodashTakeWhile1x1<T>;
4165
4168
  <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashTakeWhile1x2<T>;
4166
4169
  <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
4167
4170
  }
4168
4171
  type LodashTakeWhile1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
4169
4172
  type LodashTakeWhile1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
4170
- interface LodashTap {
4173
+ interface LodashTap extends LodashConvertible {
4171
4174
  <T>(interceptor: (value: T) => void): LodashTap1x1<T>;
4172
4175
  <T>(interceptor: lodash.__, value: T): LodashTap1x2<T>;
4173
4176
  <T>(interceptor: (value: T) => void, value: T): T;
@@ -4175,28 +4178,28 @@ declare namespace _ {
4175
4178
  type LodashTap1x1<T> = (value: T) => T;
4176
4179
  type LodashTap1x2<T> = (interceptor: (value: T) => void) => T;
4177
4180
  type LodashTemplate = (string: string) => lodash.TemplateExecutor;
4178
- interface LodashThrottle {
4181
+ interface LodashThrottle extends LodashConvertible {
4179
4182
  (wait: number): LodashThrottle1x1;
4180
4183
  <T extends (...args: any[]) => any>(wait: lodash.__, func: T): LodashThrottle1x2<T>;
4181
4184
  <T extends (...args: any[]) => any>(wait: number, func: T): T & lodash.Cancelable;
4182
4185
  }
4183
4186
  type LodashThrottle1x1 = <T extends (...args: any[]) => any>(func: T) => T & lodash.Cancelable;
4184
4187
  type LodashThrottle1x2<T> = (wait: number) => T & lodash.Cancelable;
4185
- interface LodashThru {
4188
+ interface LodashThru extends LodashConvertible {
4186
4189
  <T, TResult>(interceptor: (value: T) => TResult): LodashThru1x1<T, TResult>;
4187
4190
  <T>(interceptor: lodash.__, value: T): LodashThru1x2<T>;
4188
4191
  <T, TResult>(interceptor: (value: T) => TResult, value: T): TResult;
4189
4192
  }
4190
4193
  type LodashThru1x1<T, TResult> = (value: T) => TResult;
4191
4194
  type LodashThru1x2<T> = <TResult>(interceptor: (value: T) => TResult) => TResult;
4192
- interface LodashTimes {
4195
+ interface LodashTimes extends LodashConvertible {
4193
4196
  <TResult>(iteratee: (num: number) => TResult): LodashTimes1x1<TResult>;
4194
4197
  (iteratee: lodash.__, n: number): LodashTimes1x2;
4195
4198
  <TResult>(iteratee: (num: number) => TResult, n: number): TResult[];
4196
4199
  }
4197
4200
  type LodashTimes1x1<TResult> = (n: number) => TResult[];
4198
4201
  type LodashTimes1x2 = <TResult>(iteratee: (num: number) => TResult) => TResult[];
4199
- interface LodashToArray {
4202
+ interface LodashToArray extends LodashConvertible {
4200
4203
  <T>(value: lodash.List<T> | lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T[];
4201
4204
  <T>(value: T): Array<T[keyof T]>;
4202
4205
  (): any[];
@@ -4211,7 +4214,7 @@ declare namespace _ {
4211
4214
  type LodashToSafeInteger = (value: any) => number;
4212
4215
  type LodashToString = (value: any) => string;
4213
4216
  type LodashToUpper = (string: string) => string;
4214
- interface LodashTransform {
4217
+ interface LodashTransform extends LodashConvertible {
4215
4218
  <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult[]>): LodashTransform1x1<T, TResult>;
4216
4219
  <TResult>(iteratee: lodash.__, accumulator: ReadonlyArray<TResult>): LodashTransform1x2<TResult>;
4217
4220
  <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult[]>, accumulator: ReadonlyArray<TResult>): LodashTransform1x3<T, TResult>;
@@ -4282,21 +4285,21 @@ declare namespace _ {
4282
4285
  type LodashTransform4x5<TResult> = (accumulator: ReadonlyArray<TResult>) => TResult[];
4283
4286
  type LodashTransform4x6<T, TResult> = (iteratee: lodash.MemoVoidIteratorCapped<T, TResult[]>) => TResult[];
4284
4287
  type LodashTrim = (string: string) => string;
4285
- interface LodashTrimChars {
4288
+ interface LodashTrimChars extends LodashConvertible {
4286
4289
  (chars: string): LodashTrimChars1x1;
4287
4290
  (chars: lodash.__, string: string): LodashTrimChars1x2;
4288
4291
  (chars: string, string: string): string;
4289
4292
  }
4290
4293
  type LodashTrimChars1x1 = (string: string) => string;
4291
4294
  type LodashTrimChars1x2 = (chars: string) => string;
4292
- interface LodashTrimCharsEnd {
4295
+ interface LodashTrimCharsEnd extends LodashConvertible {
4293
4296
  (chars: string): LodashTrimCharsEnd1x1;
4294
4297
  (chars: lodash.__, string: string): LodashTrimCharsEnd1x2;
4295
4298
  (chars: string, string: string): string;
4296
4299
  }
4297
4300
  type LodashTrimCharsEnd1x1 = (string: string) => string;
4298
4301
  type LodashTrimCharsEnd1x2 = (chars: string) => string;
4299
- interface LodashTrimCharsStart {
4302
+ interface LodashTrimCharsStart extends LodashConvertible {
4300
4303
  (chars: string): LodashTrimCharsStart1x1;
4301
4304
  (chars: lodash.__, string: string): LodashTrimCharsStart1x2;
4302
4305
  (chars: string, string: string): string;
@@ -4305,7 +4308,7 @@ declare namespace _ {
4305
4308
  type LodashTrimCharsStart1x2 = (chars: string) => string;
4306
4309
  type LodashTrimEnd = (string: string) => string;
4307
4310
  type LodashTrimStart = (string: string) => string;
4308
- interface LodashTruncate {
4311
+ interface LodashTruncate extends LodashConvertible {
4309
4312
  (options: lodash.TruncateOptions): LodashTruncate1x1;
4310
4313
  (options: lodash.__, string: string): LodashTruncate1x2;
4311
4314
  (options: lodash.TruncateOptions, string: string): string;
@@ -4315,14 +4318,14 @@ declare namespace _ {
4315
4318
  type LodashUnapply = (func: (...args: any[]) => any) => (...args: any[]) => any;
4316
4319
  type LodashUnary = <T, TResult>(func: (arg1: T, ...args: any[]) => TResult) => (arg1: T) => TResult;
4317
4320
  type LodashUnescape = (string: string) => string;
4318
- interface LodashUnion {
4321
+ interface LodashUnion extends LodashConvertible {
4319
4322
  <T>(arrays2: lodash.List<T> | null | undefined): LodashUnion1x1<T>;
4320
4323
  <T>(arrays2: lodash.__, arrays: lodash.List<T> | null | undefined): LodashUnion1x2<T>;
4321
4324
  <T>(arrays2: lodash.List<T> | null | undefined, arrays: lodash.List<T> | null | undefined): T[];
4322
4325
  }
4323
4326
  type LodashUnion1x1<T> = (arrays: lodash.List<T> | null | undefined) => T[];
4324
4327
  type LodashUnion1x2<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
4325
- interface LodashUnionBy {
4328
+ interface LodashUnionBy extends LodashConvertible {
4326
4329
  <T>(iteratee: lodash.ValueIteratee<T>): LodashUnionBy1x1<T>;
4327
4330
  <T>(iteratee: lodash.__, arrays1: lodash.List<T> | null | undefined): LodashUnionBy1x2<T>;
4328
4331
  <T>(iteratee: lodash.ValueIteratee<T>, arrays1: lodash.List<T> | null | undefined): LodashUnionBy1x3<T>;
@@ -4349,7 +4352,7 @@ declare namespace _ {
4349
4352
  }
4350
4353
  type LodashUnionBy1x5<T> = (arrays1: lodash.List<T> | null | undefined) => T[];
4351
4354
  type LodashUnionBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
4352
- interface LodashUnionWith {
4355
+ interface LodashUnionWith extends LodashConvertible {
4353
4356
  <T>(comparator: lodash.Comparator<T>): LodashUnionWith1x1<T>;
4354
4357
  <T>(comparator: lodash.__, arrays: lodash.List<T> | null | undefined): LodashUnionWith1x2<T>;
4355
4358
  <T>(comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined): LodashUnionWith1x3<T>;
@@ -4377,7 +4380,7 @@ declare namespace _ {
4377
4380
  type LodashUnionWith1x5<T> = (arrays: lodash.List<T> | null | undefined) => T[];
4378
4381
  type LodashUnionWith1x6<T> = (comparator: lodash.Comparator<T>) => T[];
4379
4382
  type LodashUniq = <T>(array: lodash.List<T> | null | undefined) => T[];
4380
- interface LodashUniqBy {
4383
+ interface LodashUniqBy extends LodashConvertible {
4381
4384
  <T>(iteratee: lodash.ValueIteratee<T>): LodashUniqBy1x1<T>;
4382
4385
  <T>(iteratee: lodash.__, array: lodash.List<T> | null | undefined): LodashUniqBy1x2<T>;
4383
4386
  <T>(iteratee: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
@@ -4385,7 +4388,7 @@ declare namespace _ {
4385
4388
  type LodashUniqBy1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
4386
4389
  type LodashUniqBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
4387
4390
  type LodashUniqueId = (prefix: string) => string;
4388
- interface LodashUniqWith {
4391
+ interface LodashUniqWith extends LodashConvertible {
4389
4392
  <T>(comparator: lodash.Comparator<T>): LodashUniqWith1x1<T>;
4390
4393
  <T>(comparator: lodash.__, array: lodash.List<T> | null | undefined): LodashUniqWith1x2<T>;
4391
4394
  <T>(comparator: lodash.Comparator<T>, array: lodash.List<T> | null | undefined): T[];
@@ -4393,14 +4396,14 @@ declare namespace _ {
4393
4396
  type LodashUniqWith1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
4394
4397
  type LodashUniqWith1x2<T> = (comparator: lodash.Comparator<T>) => T[];
4395
4398
  type LodashUnzip = <T>(array: T[][] | lodash.List<lodash.List<T>> | null | undefined) => T[][];
4396
- interface LodashUnzipWith {
4399
+ interface LodashUnzipWith extends LodashConvertible {
4397
4400
  <T, TResult>(iteratee: (...values: T[]) => TResult): LodashUnzipWith1x1<T, TResult>;
4398
4401
  <T>(iteratee: lodash.__, array: lodash.List<lodash.List<T>> | null | undefined): LodashUnzipWith1x2<T>;
4399
4402
  <T, TResult>(iteratee: (...values: T[]) => TResult, array: lodash.List<lodash.List<T>> | null | undefined): TResult[];
4400
4403
  }
4401
4404
  type LodashUnzipWith1x1<T, TResult> = (array: lodash.List<lodash.List<T>> | null | undefined) => TResult[];
4402
4405
  type LodashUnzipWith1x2<T> = <TResult>(iteratee: (...values: T[]) => TResult) => TResult[];
4403
- interface LodashUpdate {
4406
+ interface LodashUpdate extends LodashConvertible {
4404
4407
  (path: lodash.PropertyPath): LodashUpdate1x1;
4405
4408
  (path: lodash.__, updater: (value: any) => any): LodashUpdate1x2;
4406
4409
  (path: lodash.PropertyPath, updater: (value: any) => any): LodashUpdate1x3;
@@ -4427,7 +4430,7 @@ declare namespace _ {
4427
4430
  }
4428
4431
  type LodashUpdate1x5 = (updater: (value: any) => any) => any;
4429
4432
  type LodashUpdate1x6 = (path: lodash.PropertyPath) => any;
4430
- interface LodashUpdateWith {
4433
+ interface LodashUpdateWith extends LodashConvertible {
4431
4434
  <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x1<T>;
4432
4435
  (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x2;
4433
4436
  <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashUpdateWith1x3<T>;
@@ -4516,16 +4519,16 @@ declare namespace _ {
4516
4519
  type LodashUpdateWith1x14<T> = (customizer: lodash.SetWithCustomizer<T>) => T;
4517
4520
  type LodashUpperCase = (string: string) => string;
4518
4521
  type LodashUpperFirst = (string: string) => string;
4519
- interface LodashValues {
4522
+ interface LodashValues extends LodashConvertible {
4520
4523
  <T>(object: lodash.Dictionary<T> | lodash.NumericDictionary<T> | lodash.List<T> | null | undefined): T[];
4521
4524
  <T extends object>(object: T | null | undefined): Array<T[keyof T]>;
4522
4525
  (object: any): any[];
4523
4526
  }
4524
- interface LodashValuesIn {
4527
+ interface LodashValuesIn extends LodashConvertible {
4525
4528
  <T>(object: lodash.Dictionary<T>|lodash.NumericDictionary<T>|lodash.List<T> | null | undefined): T[];
4526
4529
  <T extends object>(object: T | null | undefined): Array<T[keyof T]>;
4527
4530
  }
4528
- interface LodashWithout {
4531
+ interface LodashWithout extends LodashConvertible {
4529
4532
  <T>(values: ReadonlyArray<T>): LodashWithout1x1<T>;
4530
4533
  <T>(values: lodash.__, array: lodash.List<T> | null | undefined): LodashWithout1x2<T>;
4531
4534
  <T>(values: ReadonlyArray<T>, array: lodash.List<T> | null | undefined): T[];
@@ -4533,7 +4536,7 @@ declare namespace _ {
4533
4536
  type LodashWithout1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
4534
4537
  type LodashWithout1x2<T> = (values: ReadonlyArray<T>) => T[];
4535
4538
  type LodashWords = (string: string) => string[];
4536
- interface LodashWrap {
4539
+ interface LodashWrap extends LodashConvertible {
4537
4540
  <T, TArgs, TResult>(wrapper: (value: T, ...args: TArgs[]) => TResult): LodashWrap1x1<T, TArgs, TResult>;
4538
4541
  <T>(wrapper: lodash.__, value: T): LodashWrap1x2<T>;
4539
4542
  <T, TArgs, TResult>(wrapper: (value: T, ...args: TArgs[]) => TResult, value: T): (...args: TArgs[]) => TResult;
@@ -4546,35 +4549,35 @@ declare namespace _ {
4546
4549
  <TResult>(wrapper: (value: T, ...args: any[]) => TResult): (...args: any[]) => TResult;
4547
4550
  }
4548
4551
  type LodashWrap2x1<T, TResult> = (value: T) => (...args: any[]) => TResult;
4549
- interface LodashZip {
4552
+ interface LodashZip extends LodashConvertible {
4550
4553
  <T1>(arrays1: lodash.List<T1>): LodashZip1x1<T1>;
4551
4554
  <T2>(arrays1: lodash.__, arrays2: lodash.List<T2>): LodashZip1x2<T2>;
4552
4555
  <T1, T2>(arrays1: lodash.List<T1>, arrays2: lodash.List<T2>): Array<[T1 | undefined, T2 | undefined]>;
4553
4556
  }
4554
4557
  type LodashZip1x1<T1> = <T2>(arrays2: lodash.List<T2>) => Array<[T1 | undefined, T2 | undefined]>;
4555
4558
  type LodashZip1x2<T2> = <T1>(arrays1: lodash.List<T1>) => Array<[T1 | undefined, T2 | undefined]>;
4556
- interface LodashZipAll {
4559
+ interface LodashZipAll extends LodashConvertible {
4557
4560
  <T1, T2>(arrays1: [lodash.List<T1>, lodash.List<T2>]): Array<[T1 | undefined, T2 | undefined]>;
4558
4561
  <T1, T2, T3>(arrays1: [lodash.List<T1>, lodash.List<T2>, lodash.List<T3>]): Array<[T1 | undefined, T2 | undefined, T3 | undefined]>;
4559
4562
  <T1, T2, T3, T4>(arrays1: [lodash.List<T1>, lodash.List<T2>, lodash.List<T3>, lodash.List<T4>]): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>;
4560
4563
  <T1, T2, T3, T4, T5>(arrays1: [lodash.List<T1>, lodash.List<T2>, lodash.List<T3>, lodash.List<T4>, lodash.List<T5>]): Array<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>;
4561
4564
  <T>(arrays: ReadonlyArray<lodash.List<T> | null | undefined>): Array<Array<T | undefined>>;
4562
4565
  }
4563
- interface LodashZipObject {
4566
+ interface LodashZipObject extends LodashConvertible {
4564
4567
  (props: lodash.List<lodash.PropertyName>): LodashZipObject1x1;
4565
4568
  <T>(props: lodash.__, values: lodash.List<T>): LodashZipObject1x2<T>;
4566
4569
  <T>(props: lodash.List<lodash.PropertyName>, values: lodash.List<T>): lodash.Dictionary<T>;
4567
4570
  }
4568
4571
  type LodashZipObject1x1 = <T>(values: lodash.List<T>) => lodash.Dictionary<T>;
4569
4572
  type LodashZipObject1x2<T> = (props: lodash.List<lodash.PropertyName>) => lodash.Dictionary<T>;
4570
- interface LodashZipObjectDeep {
4573
+ interface LodashZipObjectDeep extends LodashConvertible {
4571
4574
  (paths: lodash.List<lodash.PropertyPath>): LodashZipObjectDeep1x1;
4572
4575
  (paths: lodash.__, values: lodash.List<any>): LodashZipObjectDeep1x2;
4573
4576
  (paths: lodash.List<lodash.PropertyPath>, values: lodash.List<any>): object;
4574
4577
  }
4575
4578
  type LodashZipObjectDeep1x1 = (values: lodash.List<any>) => object;
4576
4579
  type LodashZipObjectDeep1x2 = (paths: lodash.List<lodash.PropertyPath>) => object;
4577
- interface LodashZipWith {
4580
+ interface LodashZipWith extends LodashConvertible {
4578
4581
  <T1, T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x1<T1, T2, TResult>;
4579
4582
  <T1>(iteratee: lodash.__, arrays1: lodash.List<T1>): LodashZipWith1x2<T1>;
4580
4583
  <T1, T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List<T1>): LodashZipWith1x3<T2, TResult>;