Batch upload via PowerShell script (Batch 5 of 51)

code-dump-part021.txt

sult>;
        <T>(iteratee: lodash.__, depth: number, collection: lodash.List<T> | null | undefined): LodashFlatMapDepth1x6<T>;
        <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: number, collection: lodash.List<T> | null | undefined): TResult[];
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDepth2x1<T, TResult>;
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: number): LodashFlatMapDepth2x3<T, TResult>;
        <T extends object>(iteratee: lodash.__, depth: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x4<T>;
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x5<TResult>;
        <T extends object>(iteratee: lodash.__, depth: number, collection: T | null | undefined): LodashFlatMapDepth2x6<T>;
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: number, collection: T | null | undefined): TResult[];
        (iteratee: string): LodashFlatMapDepth3x1;
        (iteratee: string, depth: number): LodashFlatMapDepth3x3;
        (iteratee: lodash.__, depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x4;
        (iteratee: string, depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x5;
        (iteratee: lodash.__, depth: number, collection: object | null | undefined): LodashFlatMapDepth3x6;
        (iteratee: string, depth: number, collection: object | null | undefined): any[];
        (iteratee: object): LodashFlatMapDepth4x1;
        (iteratee: object, depth: number): LodashFlatMapDepth4x3;
        (iteratee: object, depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth4x5;
        (iteratee: object, depth: number, collection: object | null | undefined): boolean[];
    }
    interface LodashFlatMapDepth1x1<T, TResult> {
        (depth: number): LodashFlatMapDepth1x3<T, TResult>;
        (depth: lodash.__, collection: lodash.List<T> | null | undefined): LodashFlatMapDepth1x5<TResult>;
        (depth: number, collection: lodash.List<T> | null | undefined): TResult[];
    }
    interface LodashFlatMapDepth1x2 {
        <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDepth1x3<T, TResult>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashFlatMapDepth1x6<T>;
        <T, TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, collection: lodash.List<T> | null | undefined): TResult[];
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDepth2x3<T, TResult>;
        <T extends object>(iteratee: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x6<T>;
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, collection: T | null | undefined): TResult[];
        (iteratee: string): LodashFlatMapDepth3x3;
        (iteratee: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x6;
        (iteratee: string, collection: object | null | undefined): any[];
        (iteratee: object): LodashFlatMapDepth4x3;
        (iteratee: object, collection: object | null | undefined): boolean[];
    }
    type LodashFlatMapDepth1x3<T, TResult> = (collection: lodash.List<T> | null | undefined) => TResult[];
    interface LodashFlatMapDepth1x4<T> {
        <TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDepth1x5<TResult>;
        (iteratee: lodash.__, depth: number): LodashFlatMapDepth1x6<T>;
        <TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: number): TResult[];
    }
    type LodashFlatMapDepth1x5<TResult> = (depth: number) => TResult[];
    type LodashFlatMapDepth1x6<T> = <TResult>(iteratee: (value: T) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult) => TResult[];
    interface LodashFlatMapDepth2x1<T, TResult> {
        (depth: number): LodashFlatMapDepth2x3<T, TResult>;
        (depth: lodash.__, collection: T | null | undefined): LodashFlatMapDepth2x5<TResult>;
        (depth: number, collection: T | null | undefined): TResult[];
    }
    type LodashFlatMapDepth2x3<T, TResult> = (collection: T | null | undefined) => TResult[];
    interface LodashFlatMapDepth2x4<T> {
        <TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult): LodashFlatMapDepth2x5<TResult>;
        (iteratee: lodash.__, depth: number): LodashFlatMapDepth2x6<T>;
        <TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult, depth: number): TResult[];
    }
    type LodashFlatMapDepth2x5<TResult> = (depth: number) => TResult[];
    type LodashFlatMapDepth2x6<T> = <TResult>(iteratee: (value: T[keyof T]) => lodash.ListOfRecursiveArraysOrValues<TResult> | TResult) => TResult[];
    interface LodashFlatMapDepth3x1 {
        (depth: number): LodashFlatMapDepth3x3;
        (depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth3x5;
        (depth: number, collection: object | null | undefined): any[];
    }
    type LodashFlatMapDepth3x3 = (collection: object | null | undefined) => any[];
    interface LodashFlatMapDepth3x4 {
        (iteratee: string): LodashFlatMapDepth3x5;
        (iteratee: lodash.__, depth: number): LodashFlatMapDepth3x6;
        (iteratee: string, depth: number): any[];
        (iteratee: object): LodashFlatMapDepth4x5;
        (iteratee: object, depth: number): boolean[];
    }
    type LodashFlatMapDepth3x5 = (depth: number) => any[];
    interface LodashFlatMapDepth3x6 {
        (iteratee: string): any[];
        (iteratee: object): boolean[];
    }
    interface LodashFlatMapDepth4x1 {
        (depth: number): LodashFlatMapDepth4x3;
        (depth: lodash.__, collection: object | null | undefined): LodashFlatMapDepth4x5;
        (depth: number, collection: object | null | undefined): boolean[];
    }
    type LodashFlatMapDepth4x3 = (collection: object | null | undefined) => boolean[];
    type LodashFlatMapDepth4x5 = (depth: number) => boolean[];
    type LodashFlatten = <T>(array: lodash.List<lodash.Many<T>> | null | undefined) => T[];
    type LodashFlattenDeep = <T>(array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined) => T[];
    interface LodashFlattenDepth {
        (depth: number): LodashFlattenDepth1x1;
        <T>(depth: lodash.__, array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined): LodashFlattenDepth1x2<T>;
        <T>(depth: number, array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined): T[];
    }
    type LodashFlattenDepth1x1 = <T>(array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined) => T[];
    type LodashFlattenDepth1x2<T> = (depth: number) => T[];
    type LodashFlip = <T extends (...args: any) => any>(func: T) => T;
    type LodashFloor = (n: number) => number;
    interface LodashFlow {
        <A extends any[], R1, R2, R3, R4, R5, R6, R7>(f1: (...args: A) => 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): (...args: A) => R7;
        <A extends any[], R1, R2, R3, R4, R5, R6, R7>(f1: (...args: A) => 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, ...func: Array<lodash.Many<(a: any) => any>>): (...args: A) => any;
        <A extends any[], R1, R2, R3, R4, R5, R6>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5, f6: (a: R5) => R6): (...args: A) => R6;
        <A extends any[], R1, R2, R3, R4, R5>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4, f5: (a: R4) => R5): (...args: A) => R5;
        <A extends any[], R1, R2, R3, R4>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3, f4: (a: R3) => R4): (...args: A) => R4;
        <A extends any[], R1, R2, R3>(f1: (...args: A) => R1, f2: (a: R1) => R2, f3: (a: R2) => R3): (...args: A) => R3;
        <A extends any[], R1, R2>(f1: (...args: A) => R1, f2: (a: R1) => R2): (...args: A) => R2;
        (...func: Array<lodash.Many<(...args: any[]) => any>>): (...args: any[]) => any;
    }
    interface LodashForIn {
        <T>(iteratee: (value: T) => any): LodashForIn1x1<T>;
        <T>(iteratee: lodash.__, object: T): LodashForIn1x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
        <T>(iteratee: lodash.__, object: T | null | undefined): LodashForIn2x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined;
    }
    interface LodashForIn1x1<T> {
        <T1 extends object>(object: T1): T1;
        <T1 extends object>(object: T1 | null | undefined): T1 | null | undefined;
    }
    type LodashForIn1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
    type LodashForIn2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
    interface LodashForInRight {
        <T>(iteratee: (value: T) => any): LodashForInRight1x1<T>;
        <T>(iteratee: lodash.__, object: T): LodashForInRight1x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
        <T>(iteratee: lodash.__, object: T | null | undefined): LodashForInRight2x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined;
    }
    interface LodashForInRight1x1<T> {
        <T1 extends object>(object: T1): T1;
        <T1 extends object>(object: T1 | null | undefined): T1 | null | undefined;
    }
    type LodashForInRight1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
    type LodashForInRight2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
    interface LodashForOwn {
        <T>(iteratee: (value: T) => any): LodashForOwn1x1<T>;
        <T>(iteratee: lodash.__, object: T): LodashForOwn1x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
        <T>(iteratee: lodash.__, object: T | null | undefined): LodashForOwn2x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined;
    }
    interface LodashForOwn1x1<T> {
        <T1 extends object>(object: T1): T1;
        <T1 extends object>(object: T1 | null | undefined): T1 | null | undefined;
    }
    type LodashForOwn1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
    type LodashForOwn2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
    interface LodashForOwnRight {
        <T>(iteratee: (value: T) => any): LodashForOwnRight1x1<T>;
        <T>(iteratee: lodash.__, object: T): LodashForOwnRight1x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T): T;
        <T>(iteratee: lodash.__, object: T | null | undefined): LodashForOwnRight2x2<T>;
        <T>(iteratee: (value: T[keyof T]) => any, object: T | null | undefined): T | null | undefined;
    }
    interface LodashForOwnRight1x1<T> {
        <T1 extends object>(object: T1): T1;
        <T1 extends object>(object: T1 | null | undefined): T1 | null | undefined;
    }
    type LodashForOwnRight1x2<T> = (iteratee: (value: T[keyof T]) => any) => T;
    type LodashForOwnRight2x2<T> = (iteratee: (value: T[keyof T]) => any) => T | null | undefined;
    interface LodashFromPairs {
        <T>(pairs: lodash.List<[lodash.PropertyName, T]> | null | undefined): lodash.Dictionary<T>;
        (pairs: lodash.List<any[]> | null | undefined): lodash.Dictionary<any>;
    }
    type LodashFunctions = (object: any) => string[];
    type LodashFunctionsIn = (object: any) => string[];
    interface LodashGet {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashGet1x1<TObject, TKey>;
        <TObject extends object>(path: lodash.__, object: TObject): LodashGet1x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashGet2x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashGet3x1<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject): TObject[TKey1][TKey2];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashGet5x1<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject): TObject[TKey1][TKey2][TKey3];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashGet7x1<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
        (path: number): LodashGet9x1;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T>): LodashGet9x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T>): T;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashGet10x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
        (path: lodash.PropertyPath): LodashGet11x1;
        (path: lodash.__, object: null | undefined): LodashGet11x2;
        (path: lodash.PropertyPath, object: null | undefined): undefined;
        (path: lodash.__, object: any): LodashGet12x2;
        (path: lodash.PropertyPath, object: any): any;
    }
    interface LodashGet1x1<TObject, TKey extends keyof TObject> {
        (object: TObject): TObject[TKey];
        (object: TObject | null | undefined): TObject[TKey] | undefined;
    }
    interface LodashGet1x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
    }
    interface LodashGet2x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashGet3x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        (object: TObject): TObject[TKey1][TKey2];
        (object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
    }
    interface LodashGet5x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
    }
    interface LodashGet7x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashGet9x1 {
        <T>(object: lodash.NumericDictionary<T>): T;
        <T>(object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
    }
    type LodashGet9x2<T> = (path: number) => T;
    type LodashGet10x2<T> = (path: number) => T | undefined;
    interface LodashGet11x1 {
        (object: null | undefined): undefined;
        (object: any): any;
    }
    type LodashGet11x2 = (path: lodash.PropertyPath) => undefined;
    type LodashGet12x2 = (path: lodash.PropertyPath) => any;
    interface LodashGetOr {
        <TDefault>(defaultValue: TDefault): LodashGetOr1x1<TDefault>;
        <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashGetOr1x2<TObject, TKey>;
        <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): LodashGetOr1x3<TObject, TKey, TDefault>;
        <TObject extends object>(defaultValue: lodash.__, path: lodash.__, object: TObject | null | undefined): LodashGetOr1x4<TObject>;
        <TObject extends object, TDefault>(defaultValue: TDefault, path: lodash.__, object: TObject | null | undefined): LodashGetOr1x5<TObject, TDefault>;
        <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey], object: TObject | null | undefined): LodashGetOr1x6<TObject, TKey>;
        <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey], object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2]): LodashGetOr2x2<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2]): LodashGetOr2x3<TObject, TKey1, TKey2, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2], object: TObject | null | undefined): LodashGetOr2x6<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3]): LodashGetOr3x2<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3]): LodashGetOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): LodashGetOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4]): LodashGetOr4x2<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4]): LodashGetOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): LodashGetOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
        (defaultValue: lodash.__, path: number): LodashGetOr5x2;
        <TDefault>(defaultValue: TDefault, path: number): LodashGetOr5x3<TDefault>;
        <T>(defaultValue: lodash.__, path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashGetOr5x4<T>;
        <T, TDefault>(defaultValue: TDefault, path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashGetOr5x5<T, TDefault>;
        <T>(defaultValue: lodash.__, path: number, object: lodash.NumericDictionary<T> | null | undefined): LodashGetOr5x6<T>;
        <T, TDefault>(defaultValue: TDefault, path: number, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashGetOr6x2;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath): LodashGetOr6x3<TDefault>;
        (defaultValue: lodash.__, path: lodash.__, object: null | undefined): LodashGetOr6x4;
        <TDefault>(defaultValue: TDefault, path: lodash.__, object: null | undefined): LodashGetOr6x5<TDefault>;
        (defaultValue: lodash.__, path: lodash.PropertyPath, object: null | undefined): LodashGetOr6x6;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath, object: null | undefined): TDefault;
        (defaultValue: any): LodashGetOr7x1;
        (defaultValue: any, path: lodash.PropertyPath): LodashGetOr7x3;
        (defaultValue: lodash.__, path: lodash.__, object: any): LodashGetOr7x4;
        (defaultValue: any, path: lodash.__, object: any): LodashGetOr7x5;
        (defaultValue: lodash.__, path: lodash.PropertyPath, object: any): LodashGetOr7x6;
        (defaultValue: any, path: lodash.PropertyPath, object: any): any;
    }
    interface LodashGetOr1x1<TDefault> {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashGetOr1x3<TObject, TKey, TDefault>;
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashGetOr1x5<TObject, TDefault>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashGetOr2x3<TObject, TKey1, TKey2, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashGetOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashGetOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
        (path: number): LodashGetOr5x3<TDefault>;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashGetOr5x5<T, TDefault>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
        (path: lodash.PropertyPath): LodashGetOr6x3<TDefault>;
        (path: lodash.__, object: null | undefined): LodashGetOr6x5<TDefault>;
        (path: lodash.PropertyPath, object: null | undefined): TDefault;
    }
    interface LodashGetOr1x2<TObject, TKey extends keyof TObject> {
        <TDefault>(defaultValue: TDefault): LodashGetOr1x3<TObject, TKey, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashGetOr1x6<TObject, TKey>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
    }
    type LodashGetOr1x3<TObject, TKey extends keyof TObject, TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey], undefined> | TDefault;
    interface LodashGetOr1x4<TObject> {
        <TDefault>(defaultValue: TDefault): LodashGetOr1x5<TObject, TDefault>;
        <TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashGetOr1x6<TObject, TKey>;
        <TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): Exclude<TObject[TKey], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2]): LodashGetOr2x6<TObject, TKey1, TKey2>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2]): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3]): LodashGetOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3]): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4]): LodashGetOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4]): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    interface LodashGetOr1x5<TObject, TDefault> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): Exclude<TObject[TKey], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    type LodashGetOr1x6<TObject, TKey extends keyof TObject> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey], undefined> | TDefault;
    interface LodashGetOr2x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        <TDefault>(defaultValue: TDefault): LodashGetOr2x3<TObject, TKey1, TKey2, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashGetOr2x6<TObject, TKey1, TKey2>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    }
    type LodashGetOr2x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    type LodashGetOr2x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    interface LodashGetOr3x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        <TDefault>(defaultValue: TDefault): LodashGetOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashGetOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    }
    type LodashGetOr3x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    type LodashGetOr3x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    interface LodashGetOr4x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        <TDefault>(defaultValue: TDefault): LodashGetOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashGetOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    type LodashGetOr4x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    type LodashGetOr4x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    interface LodashGetOr5x2 {
        <TDefault>(defaultValue: TDefault): LodashGetOr5x3<TDefault>;
        <T>(defaultValue: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashGetOr5x6<T>;
        <T, TDefault>(defaultValue: TDefault, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
    }
    type LodashGetOr5x3<TDefault> = <T>(object: lodash.NumericDictionary<T> | null | undefined) => T | TDefault;
    interface LodashGetOr5x4<T> {
        <TDefault>(defaultValue: TDefault): LodashGetOr5x5<T, TDefault>;
        (defaultValue: lodash.__, path: number): LodashGetOr5x6<T>;
        <TDefault>(defaultValue: TDefault, path: number): T | TDefault;
    }
    type LodashGetOr5x5<T, TDefault> = (path: number) => T | TDefault;
    type LodashGetOr5x6<T> = <TDefault>(defaultValue: TDefault) => T | TDefault;
    interface LodashGetOr6x2 {
        <TDefault>(defaultValue: TDefault): LodashGetOr6x3<TDefault>;
        (defaultValue: lodash.__, object: null | undefined): LodashGetOr6x6;
        <TDefault>(defaultValue: TDefault, object: null | undefined): TDefault;
        (defaultValue: any): LodashGetOr7x3;
        (defaultValue: lodash.__, object: any): LodashGetOr7x6;
        (defaultValue: any, object: any): any;
    }
    type LodashGetOr6x3<TDefault> = (object: null | undefined) => TDefault;
    interface LodashGetOr6x4 {
        <TDefault>(defaultValue: TDefault): LodashGetOr6x5<TDefault>;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashGetOr6x6;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath): TDefault;
    }
    type LodashGetOr6x5<TDefault> = (path: lodash.PropertyPath) => TDefault;
    type LodashGetOr6x6 = <TDefault>(defaultValue: TDefault) => TDefault;
    interface LodashGetOr7x1 {
        (path: lodash.PropertyPath): LodashGetOr7x3;
        (path: lodash.__, object: any): LodashGetOr7x5;
        (path: lodash.PropertyPath, object: any): any;
    }
    type LodashGetOr7x3 = (object: any) => any;
    interface LodashGetOr7x4 {
        (defaultValue: any): LodashGetOr7x5;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashGetOr7x6;
        (defaultValue: any, path: lodash.PropertyPath): any;
    }
    type LodashGetOr7x5 = (path: lodash.PropertyPath) => any;
    type LodashGetOr7x6 = (defaultValue: any) => any;
    interface LodashGroupBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashGroupBy1x1<T>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashGroupBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<T[]>;
        <T extends object>(iteratee: lodash.__, collection: T | null | undefined): LodashGroupBy2x2<T>;
        <T extends object>(iteratee: lodash.ValueIteratee<T[keyof T]>, collection: T | null | undefined): lodash.Dictionary<Array<T[keyof T]>>;
    }
    type LodashGroupBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => lodash.Dictionary<T[]>;
    type LodashGroupBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => lodash.Dictionary<T[]>;
    type LodashGroupBy2x2<T> = (iteratee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<Array<T[keyof T]>>;
    interface LodashGt {
        (value: any): LodashGt1x1;
        (value: lodash.__, other: any): LodashGt1x2;
        (value: any, other: any): boolean;
    }
    type LodashGt1x1 = (other: any) => boolean;
    type LodashGt1x2 = (value: any) => boolean;
    interface LodashGte {
        (value: any): LodashGte1x1;
        (value: lodash.__, other: any): LodashGte1x2;
        (value: any, other: any): boolean;
    }
    type LodashGte1x1 = (other: any) => boolean;
    type LodashGte1x2 = (value: any) => boolean;
    interface LodashHas {
        (path: lodash.PropertyPath): LodashHas1x1;
        <T>(path: lodash.__, object: T): LodashHas1x2;
        <T>(path: lodash.PropertyPath, object: T): boolean;
    }
    type LodashHas1x1 = <T>(object: T) => boolean;
    type LodashHas1x2 = (path: lodash.PropertyPath) => boolean;
    interface LodashHasIn {
        (path: lodash.PropertyPath): LodashHasIn1x1;
        <T>(path: lodash.__, object: T): LodashHasIn1x2;
        <T>(path: lodash.PropertyPath, object: T): boolean;
    }
    type LodashHasIn1x1 = <T>(object: T) => boolean;
    type LodashHasIn1x2 = (path: lodash.PropertyPath) => boolean;
    interface LodashIdentity {
        <T>(value: T): T;
        (): undefined;
    }
    interface LodashIncludes {
        <T>(target: T): LodashIncludes1x1<T>;
        <T>(target: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludes1x2<T>;
        <T>(target: T, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean;
    }
    type LodashIncludes1x1<T> = (collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => boolean;
    type LodashIncludes1x2<T> = (target: T) => boolean;
    interface LodashIncludesFrom {
        <T>(target: T): LodashIncludesFrom1x1<T>;
        (target: lodash.__, fromIndex: number): LodashIncludesFrom1x2;
        <T>(target: T, fromIndex: number): LodashIncludesFrom1x3<T>;
        <T>(target: lodash.__, fromIndex: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludesFrom1x4<T>;
        <T>(target: T, fromIndex: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludesFrom1x5;
        <T>(target: lodash.__, fromIndex: number, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludesFrom1x6<T>;
        <T>(target: T, fromIndex: number, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean;
    }
    interface LodashIncludesFrom1x1<T> {
        (fromIndex: number): LodashIncludesFrom1x3<T>;
        (fromIndex: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludesFrom1x5;
        (fromIndex: number, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean;
    }
    interface LodashIncludesFrom1x2 {
        <T>(target: T): LodashIncludesFrom1x3<T>;
        <T>(target: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashIncludesFrom1x6<T>;
        <T>(target: T, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean;
    }
    type LodashIncludesFrom1x3<T> = (collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => boolean;
    interface LodashIncludesFrom1x4<T> {
        (target: T): LodashIncludesFrom1x5;
        (target: lodash.__, fromIndex: number): LodashIncludesFrom1x6<T>;
        (target: T, fromIndex: number): boolean;
    }
    type LodashIncludesFrom1x5 = (fromIndex: number) => boolean;
    type LodashIncludesFrom1x6<T> = (target: T) => boolean;
    interface LodashKeyBy {
        <T>(iteratee: lodash.ValueIterateeCustom<T, lodash.PropertyName>): LodashKeyBy1x1<T>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashKeyBy1x2<T>;
        <T>(iteratee: lodash.ValueIterateeCustom<T, lodash.PropertyName>, collection: lodash.List<T> | null | undefined): lodash.Dictionary<T>;
        <T extends object>(iteratee: lodash.__, collection: T | null | undefined): LodashKeyBy2x2<T>;
        <T extends object>(iteratee: lodash.ValueIterateeCustom<T[keyof T], lodash.PropertyName>, collection: T | null | undefined): lodash.Dictionary<T[keyof T]>;
    }
    type LodashKeyBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => lodash.Dictionary<T>;
    type LodashKeyBy1x2<T> = (iteratee: lodash.ValueIterateeCustom<T, lodash.PropertyName>) => lodash.Dictionary<T>;
    type LodashKeyBy2x2<T> = (iteratee: lodash.ValueIterateeCustom<T[keyof T], lodash.PropertyName>) => lodash.Dictionary<T[keyof T]>;
    interface LodashIndexOf {
        <T>(value: T): LodashIndexOf1x1<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashIndexOf1x2<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
    type LodashIndexOf1x2<T> = (value: T) => number;
    interface LodashIndexOfFrom {
        <T>(value: T): LodashIndexOfFrom1x1<T>;
        (value: lodash.__, fromIndex: number): LodashIndexOfFrom1x2;
        <T>(value: T, fromIndex: number): LodashIndexOfFrom1x3<T>;
        <T>(value: lodash.__, fromIndex: lodash.__, array: lodash.List<T> | null | undefined): LodashIndexOfFrom1x4<T>;
        <T>(value: T, fromIndex: lodash.__, array: lodash.List<T> | null | undefined): LodashIndexOfFrom1x5;
        <T>(value: lodash.__, fromIndex: number, array: lodash.List<T> | null | undefined): LodashIndexOfFrom1x6<T>;
        <T>(value: T, fromIndex: number, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashIndexOfFrom1x1<T> {
        (fromIndex: number): LodashIndexOfFrom1x3<T>;
        (fromIndex: lodash.__, array: lodash.List<T> | null | undefined): LodashIndexOfFrom1x5;
        (fromIndex: number, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashIndexOfFrom1x2 {
        <T>(value: T): LodashIndexOfFrom1x3<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashIndexOfFrom1x6<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashIndexOfFrom1x3<T> = (array: lodash.List<T> | null | undefined) => number;
    interface LodashIndexOfFrom1x4<T> {
        (value: T): LodashIndexOfFrom1x5;
        (value: lodash.__, fromIndex: number): LodashIndexOfFrom1x6<T>;
        (value: T, fromIndex: number): number;
    }
    type LodashIndexOfFrom1x5 = (fromIndex: number) => number;
    type LodashIndexOfFrom1x6<T> = (value: T) => number;
    type LodashInitial = <T>(array: lodash.List<T> | null | undefined) => T[];
    interface LodashInRange {
        (start: number): LodashInRange1x1;
        (start: lodash.__, end: number): LodashInRange1x2;
        (start: number, end: number): LodashInRange1x3;
        (start: lodash.__, end: lodash.__, n: number): LodashInRange1x4;
        (start: number, end: lodash.__, n: number): LodashInRange1x5;
        (start: lodash.__, end: number, n: number): LodashInRange1x6;
        (start: number, end: number, n: number): boolean;
    }
    interface LodashInRange1x1 {
        (end: number): LodashInRange1x3;
        (end: lodash.__, n: number): LodashInRange1x5;
        (end: number, n: number): boolean;
    }
    interface LodashInRange1x2 {
        (start: number): LodashInRange1x3;
        (start: lodash.__, n: number): LodashInRange1x6;
        (start: number, n: number): boolean;
    }
    type LodashInRange1x3 = (n: number) => boolean;
    interface LodashInRange1x4 {
        (start: number): LodashInRange1x5;
        (start: lodash.__, end: number): LodashInRange1x6;
        (start: number, end: number): boolean;
    }
    type LodashInRange1x5 = (end: number) => boolean;
    type LodashInRange1x6 = (start: number) => boolean;
    interface LodashIntersection {
        <T>(arrays2: lodash.List<T> | null | undefined): LodashIntersection1x1<T>;
        <T>(arrays2: lodash.__, arrays: lodash.List<T> | null | undefined): LodashIntersection1x2<T>;
        <T>(arrays2: lodash.List<T> | null | undefined, arrays: lodash.List<T> | null | undefined): T[];
    }
    type LodashIntersection1x1<T> = (arrays: lodash.List<T> | null | undefined) => T[];
    type LodashIntersection1x2<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashIntersectionBy {
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashIntersectionBy1x1<T1, T2>;
        <T1>(iteratee: lodash.__, array: lodash.List<T1> | null): LodashIntersectionBy1x2<T1>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.List<T1> | null): LodashIntersectionBy1x3<T1, T2>;
        <T2>(iteratee: lodash.__, array: lodash.__, values: lodash.List<T2>): LodashIntersectionBy1x4<T2>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.__, values: lodash.List<T2>): LodashIntersectionBy1x5<T1>;
        <T1, T2>(iteratee: lodash.__, array: lodash.List<T1> | null, values: lodash.List<T2>): LodashIntersectionBy1x6<T1, T2>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.List<T1> | null, values: lodash.List<T2>): T1[];
    }
    interface LodashIntersectionBy1x1<T1, T2> {
        (array: lodash.List<T1> | null): LodashIntersectionBy1x3<T1, T2>;
        (array: lodash.__, values: lodash.List<T2>): LodashIntersectionBy1x5<T1>;
        (array: lodash.List<T1> | null, values: lodash.List<T2>): T1[];
    }
    interface LodashIntersectionBy1x2<T1> {
        <T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashIntersectionBy1x3<T1, T2>;
        <T2>(iteratee: lodash.__, values: lodash.List<T2>): LodashIntersectionBy1x6<T1, T2>;
        <T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.List<T2>): T1[];
    }
    type LodashIntersectionBy1x3<T1, T2> = (values: lodash.List<T2>) => T1[];
    interface LodashIntersectionBy1x4<T2> {
        <T1>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashIntersectionBy1x5<T1>;
        <T1>(iteratee: lodash.__, array: lodash.List<T1> | null): LodashIntersectionBy1x6<T1, T2>;
        <T1>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.List<T1> | null): T1[];
    }
    type LodashIntersectionBy1x5<T1> = (array: lodash.List<T1> | null) => T1[];
    type LodashIntersectionBy1x6<T1, T2> = (iteratee: lodash.ValueIteratee<T1 | T2>) => T1[];
    interface LodashIntersectionWith {
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>): LodashIntersectionWith1x1<T1, T2>;
        <T1>(comparator: lodash.__, array: lodash.List<T1> | null | undefined): LodashIntersectionWith1x2<T1>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, array: lodash.List<T1> | null | undefined): LodashIntersectionWith1x3<T1, T2>;
        <T2>(comparator: lodash.__, array: lodash.__, values: lodash.List<T2>): LodashIntersectionWith1x4<T2>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, array: lodash.__, values: lodash.List<T2>): LodashIntersectionWith1x5<T1>;
        <T1, T2>(comparator: lodash.__, array: lodash.List<T1> | null | undefined, values: lodash.List<T2>): LodashIntersectionWith1x6<T1, T2>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, array: lodash.List<T1> | null | undefined, values: lodash.List<T2>): T1[];
    }
    interface LodashIntersectionWith1x1<T1, T2> {
        (array: lodash.List<T1> | null | undefined): LodashIntersectionWith1x3<T1, T2>;
        (array: lodash.__, values: lodash.List<T2>): LodashIntersectionWith1x5<T1>;
        (array: lodash.List<T1> | null | undefined, values: lodash.List<T2>): T1[];
    }
    interface LodashIntersectionWith1x2<T1> {
        <T2>(comparator: lodash.Comparator2<T1, T2>): LodashIntersectionWith1x3<T1, T2>;
        <T2>(comparator: lodash.__, values: lodash.List<T2>): LodashIntersectionWith1x6<T1, T2>;
        <T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.List<T2>): T1[];
    }
    type LodashIntersectionWith1x3<T1, T2> = (values: lodash.List<T2>) => T1[];
    interface LodashIntersectionWith1x4<T2> {
        <T1>(comparator: lodash.Comparator2<T1, T2>): LodashIntersectionWith1x5<T1>;
        <T1>(comparator: lodash.__, array: lodash.List<T1> | null | undefined): LodashIntersectionWith1x6<T1, T2>;
        <T1>(comparator: lodash.Comparator2<T1, T2>, array: lodash.List<T1> | null | undefined): T1[];
    }
    type LodashIntersectionWith1x5<T1> = (array: lodash.List<T1> | null | undefined) => T1[];
    type LodashIntersectionWith1x6<T1, T2> = (comparator: lodash.Comparator2<T1, T2>) => T1[];
    type LodashInvert = (object: object) => lodash.Dictionary<string>;
    interface LodashInvertBy {
        <T>(interatee: lodash.ValueIteratee<T>): LodashInvertBy1x1<T>;
        <T>(interatee: lodash.__, object:  lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashInvertBy1x2<T>;
        <T>(interatee: lodash.ValueIteratee<T>, object:  lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<string[]>;
        <T extends object>(interatee: lodash.__, object: T | null | undefined): LodashInvertBy2x2<T>;
        <T extends object>(interatee: lodash.ValueIteratee<T[keyof T]>, object: T | null | undefined): lodash.Dictionary<string[]>;
    }
    type LodashInvertBy1x1<T> = (object: lodash.Dictionary<T> | lodash.NumericDictionary<T> | object | null | undefined) => lodash.Dictionary<string[]>;
    type LodashInvertBy1x2<T> = (interatee: lodash.ValueIteratee<T>) => lodash.Dictionary<string[]>;
    type LodashInvertBy2x2<T> = (interatee: lodash.ValueIteratee<T[keyof T]>) => lodash.Dictionary<string[]>;
    interface LodashInvoke {
        (path: lodash.PropertyPath): LodashInvoke1x1;
        (path: lodash.__, object: any): LodashInvoke1x2;
        (path: lodash.PropertyPath, object: any): any;
    }
    type LodashInvoke1x1 = (object: any) => any;
    type LodashInvoke1x2 = (path: lodash.PropertyPath) => any;
    interface LodashInvokeArgs {
        (path: lodash.PropertyPath): LodashInvokeArgs1x1;
        (path: lodash.__, args: readonly any[]): LodashInvokeArgs1x2;
        (path: lodash.PropertyPath, args: readonly any[]): LodashInvokeArgs1x3;
        (path: lodash.__, args: lodash.__, object: any): LodashInvokeArgs1x4;
        (path: lodash.PropertyPath, args: lodash.__, object: any): LodashInvokeArgs1x5;
        (path: lodash.__, args: readonly any[], object: any): LodashInvokeArgs1x6;
        (path: lodash.PropertyPath, args: readonly any[], object: any): any;
    }
    interface LodashInvokeArgs1x1 {
        (args: readonly any[]): LodashInvokeArgs1x3;
        (args: lodash.__, object: any): LodashInvokeArgs1x5;
        (args: readonly any[], object: any): any;
    }
    interface LodashInvokeArgs1x2 {
        (path: lodash.PropertyPath): LodashInvokeArgs1x3;
        (path: lodash.__, object: any): LodashInvokeArgs1x6;
        (path: lodash.PropertyPath, object: any): any;
    }
    type LodashInvokeArgs1x3 = (object: any) => any;
    interface LodashInvokeArgs1x4 {
        (path: lodash.PropertyPath): LodashInvokeArgs1x5;
        (path: lodash.__, args: readonly any[]): LodashInvokeArgs1x6;
        (path: lodash.PropertyPath, args: readonly any[]): any;
    }
    type LodashInvokeArgs1x5 = (args: readonly any[]) => any;
    type LodashInvokeArgs1x6 = (path: lodash.PropertyPath) => any;
    interface LodashInvokeArgsMap {
        (methodName: string): LodashInvokeArgsMap1x1;
        (methodNameOrMethod: lodash.__, args: readonly any[]): LodashInvokeArgsMap1x2;
        (methodName: string, args: readonly any[]): LodashInvokeArgsMap1x3;
        (methodNameOrMethod: lodash.__, args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x4;
        (methodName: string, args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x5;
        (methodNameOrMethod: lodash.__, args: readonly any[], collection: object | null | undefined): LodashInvokeArgsMap1x6;
        (methodName: string, args: readonly any[], collection: object | null | undefined): any[];
        <TResult>(method: (...args: any[]) => TResult): LodashInvokeArgsMap2x1<TResult>;
        <TResult>(method: (...args: any[]) => TResult, args: readonly any[]): LodashInvokeArgsMap2x3<TResult>;
        <TResult>(method: (...args: any[]) => TResult, args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap2x5<TResult>;
        <TResult>(method: (...args: any[]) => TResult, args: readonly any[], collection: object | null | undefined): TResult[];
    }
    interface LodashInvokeArgsMap1x1 {
        (args: readonly any[]): LodashInvokeArgsMap1x3;
        (args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x5;
        (args: readonly any[], collection: object | null | undefined): any[];
    }
    interface LodashInvokeArgsMap1x2 {
        (methodName: string): LodashInvokeArgsMap1x3;
        (methodNameOrMethod: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap1x6;
        (methodName: string, collection: object | null | undefined): any[];
        <TResult>(method: (...args: any[]) => TResult): LodashInvokeArgsMap2x3<TResult>;
        <TResult>(method: (...args: any[]) => TResult, collection: object | null | undefined): TResult[];
    }
    type LodashInvokeArgsMap1x3 = (collection: object | null | undefined) => any[];
    interface LodashInvokeArgsMap1x4 {
        (methodName: string): LodashInvokeArgsMap1x5;
        (methodNameOrMethod: lodash.__, args: readonly any[]): LodashInvokeArgsMap1x6;
        (methodName: string, args: readonly any[]): any[];
        <TResult>(method: (...args: any[]) => TResult): LodashInvokeArgsMap2x5<TResult>;
        <TResult>(method: (...args: any[]) => TResult, args: readonly any[]): TResult[];
    }
    type LodashInvokeArgsMap1x5 = (args: readonly any[]) => any[];
    interface LodashInvokeArgsMap1x6 {
        (methodName: string): any[];
        <TResult>(method: (...args: any[]) => TResult): TResult[];
    }
    interface LodashInvokeArgsMap2x1<TResult> {
        (args: readonly any[]): LodashInvokeArgsMap2x3<TResult>;
        (args: lodash.__, collection: object | null | undefined): LodashInvokeArgsMap2x5<TResult>;
        (args: readonly any[], collection: object | null | undefined): TResult[];
    }
    type LodashInvokeArgsMap2x3<TResult> = (collection: object | null | undefined) => TResult[];
    type LodashInvokeArgsMap2x5<TResult> = (args: readonly any[]) => TResult[];
    interface LodashInvokeMap {
        (methodName: string): LodashInvokeMap1x1;
        (methodNameOrMethod: lodash.__, collection: object | null | undefined): LodashInvokeMap1x2;
        (methodName: string, collection: object | null | undefined): any[];
        <TResult>(method: (...args: any[]) => TResult): LodashInvokeMap2x1<TResult>;
        <TResult>(method: (...args: any[]) => TResult, collection: object | null | undefined): TResult[];
    }
    type LodashInvokeMap1x1 = (collection: object | null | undefined) => any[];
    interface LodashInvokeMap1x2 {
        (methodName: string): any[];
        <TResult>(method: (...args: any[]) => TResult): TResult[];
    }
    type LodashInvokeMap2x1<TResult> = (collection: object | null | undefined) => TResult[];
    type LodashIsArguments = (value: any) => value is IArguments;
    type LodashIsArray = (value: any) => value is any[];
    type LodashIsArrayBuffer = (value: any) => value is ArrayBuffer;
    interface LodashIsArrayLike {
        <T extends { __lodashAnyHack: any }>(t: T): boolean;
        (value: ((...args: any[]) => any) | null | undefined): value is never;
        (value: any): value is { length: number };
    }
    interface LodashIsArrayLikeObject {
        <T extends { __lodashAnyHack: any }>(value: T): boolean;
        (value: ((...args: any[]) => any) | lodash.FunctionBase | string | boolean | number | null | undefined): value is never;
        (value: any): value is object & { length: number };
    }
    type LodashIsBoolean = (value: any) => value is boolean;
    type LodashIsBuffer = (value: any) => boolean;
    type LodashIsDate = (value: any) => value is Date;
    type LodashIsElement = (value: any) => boolean;
    interface LodashIsEmpty {
        <T extends { __trapAny: any }>(value: T): boolean;
        (value: string | null | undefined): value is '' | null | undefined;
        (value: any[] | null | undefined): boolean;
        (value: readonly any[] | null | undefined): value is Readonly<[]> | null | undefined;
        (value: Map<any, any> | Set<any> | lodash.List<any> | null | undefined): boolean;
        <T extends object>(value: T | null | undefined): value is lodash.EmptyObjectOf<T> | null | undefined;
        (value?: any): boolean;
    }
    interface LodashIsEqualWith {
        (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x1;
        (customizer: lodash.__, value: any): LodashIsEqualWith1x2;
        (customizer: lodash.IsEqualCustomizer, value: any): LodashIsEqualWith1x3;
        (customizer: lodash.__, value: lodash.__, other: any): LodashIsEqualWith1x4;
        (customizer: lodash.IsEqualCustomizer, value: lodash.__, other: any): LodashIsEqualWith1x5;
        (customizer: lodash.__, value: any, other: any): LodashIsEqualWith1x6;
        (customizer: lodash.IsEqualCustomizer, value: any, other: any): boolean;
    }
    interface LodashIsEqualWith1x1 {
        (value: any): LodashIsEqualWith1x3;
        (value: lodash.__, other: any): LodashIsEqualWith1x5;
        (value: any, other: any): boolean;
    }
    interface LodashIsEqualWith1x2 {
        (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x3;
        (customizer: lodash.__, other: any): LodashIsEqualWith1x6;
        (customizer: lodash.IsEqualCustomizer, other: any): boolean;
    }
    type LodashIsEqualWith1x3 = (other: any) => boolean;
    interface LodashIsEqualWith1x4 {
        (customizer: lodash.IsEqualCustomizer): LodashIsEqualWith1x5;
        (customizer: lodash.__, value: any): LodashIsEqualWith1x6;
        (customizer: lodash.IsEqualCustomizer, value: any): boolean;
    }
    type LodashIsEqualWith1x5 = (value: any) => boolean;
    type LodashIsEqualWith1x6 = (customizer: lodash.IsEqualCustomizer) => boolean;
    type LodashIsError = (value: any) => value is Error;
    type LodashIsFinite = (value: any) => boolean;
    type LodashIsFunction = (value: any) => value is (...args: any[]) => any;
    type LodashIsInteger = (value: any) => boolean;
    type LodashIsLength = (value: any) => boolean;
    type LodashIsMap = (value: any) => value is Map<any, any>;
    interface LodashIsMatch {
        (source: object): LodashIsMatch1x1;
        (source: lodash.__, object: object): LodashIsMatch1x2;
        (source: object, object: object): boolean;
    }
    type LodashIsMatch1x1 = (object: object) => boolean;
    type LodashIsMatch1x2 = (source: object) => boolean;
    interface LodashIsMatchWith {
        (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x1;
        (customizer: lodash.__, source: object): LodashIsMatchWith1x2;
        (customizer: lodash.isMatchWithCustomizer, source: object): LodashIsMatchWith1x3;
        (customizer: lodash.__, source: lodash.__, object: object): LodashIsMatchWith1x4;
        (customizer: lodash.isMatchWithCustomizer, source: lodash.__, object: object): LodashIsMatchWith1x5;
        (customizer: lodash.__, source: object, object: object): LodashIsMatchWith1x6;
        (customizer: lodash.isMatchWithCustomizer, source: object, object: object): boolean;
    }
    interface LodashIsMatchWith1x1 {
        (source: object): LodashIsMatchWith1x3;
        (source: lodash.__, object: object): LodashIsMatchWith1x5;
        (source: object, object: object): boolean;
    }
    interface LodashIsMatchWith1x2 {
        (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x3;
        (customizer: lodash.__, object: object): LodashIsMatchWith1x6;
        (customizer: lodash.isMatchWithCustomizer, object: object): boolean;
    }
    type LodashIsMatchWith1x3 = (object: object) => boolean;
    interface LodashIsMatchWith1x4 {
        (customizer: lodash.isMatchWithCustomizer): LodashIsMatchWith1x5;
        (customizer: lodash.__, source: object): LodashIsMatchWith1x6;
        (customizer: lodash.isMatchWithCustomizer, source: object): boolean;
    }
    type LodashIsMatchWith1x5 = (source: object) => boolean;
    type LodashIsMatchWith1x6 = (customizer: lodash.isMatchWithCustomizer) => boolean;
    type LodashIsNaN = (value: any) => boolean;
    type LodashIsNative = (value: any) => value is (...args: any[]) => any;
    type LodashIsNil = (value: any) => value is null | undefined;
    type LodashIsNull = (value: any) => value is null;
    type LodashIsNumber = (value: any) => value is number;
    type LodashIsObject = (value: any) => value is object;
    type LodashIsObjectLike = (value: any) => boolean;
    type LodashIsPlainObject = (value: any) => boolean;
    type LodashIsRegExp = (value: any) => value is RegExp;
    type LodashIsSafeInteger = (value: any) => boolean;
    type LodashIsSet = (value: any) => value is Set<any>;
    type LodashIsString = (value: any) => value is string;
    type LodashIsSymbol = (value: any) => value is symbol;
    type LodashIsTypedArray = (value: any) => boolean;
    type LodashIsUndefined = (value: any) => value is undefined;
    type LodashIsWeakMap = (value: any) => value is WeakMap<object, any>;
    type LodashIsWeakSet = (value: any) => value is WeakSet<object>;
    interface LodashIteratee {
        <TFunction extends (...args: any[]) => any>(func: TFunction): TFunction;
        (func: string | object): (...args: any[]) => any;
    }
    interface LodashJoin {
        (separator: string): LodashJoin1x1;
        (separator: lodash.__, array: lodash.List<any> | null | undefined): LodashJoin1x2;
        (separator: string, array: lodash.List<any> | null | undefined): string;
    }
    type LodashJoin1x1 = (array: lodash.List<any> | null | undefined) => string;
    type LodashJoin1x2 = (separator: string) => string;
    type LodashOver = <TResult>(iteratees: lodash.Many<(...args: any[]) => TResult>) => (...args: any[]) => TResult[];
    type LodashKebabCase = (string: string) => string;
    type LodashKeys = (object: any) => string[];
    type LodashKeysIn = (object: any) => string[];
    type LodashLast = <T>(array: lodash.List<T> | null | undefined) => T | undefined;
    interface LodashLastIndexOf {
        <T>(value: T): LodashLastIndexOf1x1<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashLastIndexOf1x2<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashLastIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
    type LodashLastIndexOf1x2<T> = (value: T) => number;
    interface LodashLastIndexOfFrom {
        <T>(value: T): LodashLastIndexOfFrom1x1<T>;
        (value: lodash.__, fromIndex: true|number): LodashLastIndexOfFrom1x2;
        <T>(value: T, fromIndex: true|number): LodashLastIndexOfFrom1x3<T>;
        <T>(value: lodash.__, fromIndex: lodash.__, array: lodash.List<T> | null | undefined): LodashLastIndexOfFrom1x4<T>;
        <T>(value: T, fromIndex: lodash.__, array: lodash.List<T> | null | undefined): LodashLastIndexOfFrom1x5;
        <T>(value: lodash.__, fromIndex: true|number, array: lodash.List<T> | null | undefined): LodashLastIndexOfFrom1x6<T>;
        <T>(value: T, fromIndex: true|number, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashLastIndexOfFrom1x1<T> {
        (fromIndex: true|number): LodashLastIndexOfFrom1x3<T>;
        (fromIndex: lodash.__, array: lodash.List<T> | null | undefined): LodashLastIndexOfFrom1x5;
        (fromIndex: true|number, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashLastIndexOfFrom1x2 {
        <T>(value: T): LodashLastIndexOfFrom1x3<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashLastIndexOfFrom1x6<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashLastIndexOfFrom1x3<T> = (array: lodash.List<T> | null | undefined) => number;
    interface LodashLastIndexOfFrom1x4<T> {
        (value: T): LodashLastIndexOfFrom1x5;
        (value: lodash.__, fromIndex: true|number): LodashLastIndexOfFrom1x6<T>;
        (value: T, fromIndex: true|number): number;
    }
    type LodashLastIndexOfFrom1x5 = (fromIndex: true|number) => number;
    type LodashLastIndexOfFrom1x6<T> = (value: T) => number;
    type LodashLowerCase = (string: string) => string;
    type LodashLowerFirst = <T extends string = string>(string: T) => Uncapitalize<T>;
    interface LodashLt {
        (value: any): LodashLt1x1;
        (value: lodash.__, other: any): LodashLt1x2;
        (value: any, other: any): boolean;
    }
    type LodashLt1x1 = (other: any) => boolean;
    type LodashLt1x2 = (value: any) => boolean;
    interface LodashLte {
        (value: any): LodashLte1x1;
        (value: lodash.__, other: any): LodashLte1x2;
        (value: any, other: any): boolean;
    }
    type LodashLte1x1 = (other: any) => boolean;
    type LodashLte1x2 = (value: any) => boolean;
    interface LodashMap {
        <T, TResult>(iteratee: (value: T) => TResult): LodashMap1x1<T, TResult>;
        <T>(iteratee: lodash.__, collection: T[] | null | undefined): LodashMap1x2<T>;
        <T, TResult>(iteratee: (value: T) => TResult, collection: T[] | lodash.List<T> | null | undefined): TResult[];
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMap2x2<T>;
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => TResult): LodashMap3x1<T, TResult>;
        <T extends object>(iteratee: lodash.__, collection: T | null | undefined): LodashMap3x2<T>;
        <T extends object, TResult>(iteratee: (value: T[keyof T]) => TResult, collection: T | null | undefined): TResult[];
        <T, K extends keyof T>(iteratee: K): LodashMap4x1<T, K>;
        <T>(iteratee: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashMap4x2<T>;
        <T, K extends keyof T>(iteratee: K, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): Array<T[K]>;
        (iteratee: string): LodashMap5x1;
        <T>(iteratee: string, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): any[];
        (iteratee: object): LodashMap6x1;
        <T>(iteratee: object, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): boolean[];
    }
    type LodashMap1x1<T, TResult> = (collection: T[] | lodash.List<T> | null | undefined) => TResult[];
    type LodashMap1x2<T> = <TResult>(iteratee: (value: T) => TResult) => TResult[];
    type LodashMap2x2<T> = <TResult>(iteratee: (value: T) => TResult) => TResult[];
    type LodashMap3x1<T, TResult> = (collection: T | null | undefined) => TResult[];
    type LodashMap3x2<T> = <TResult>(iteratee: (value: T[keyof T]) => TResult) => TResult[];
    type LodashMap4x1<T, K extends keyof T> = (collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => Array<T[K]>;
    interface LodashMap4x2<T> {
        <K extends keyof T>(iteratee: K): Array<T[K]>;
        (iteratee: string): any[];
        (iteratee: object): boolean[];
    }
    type LodashMap5x1 = <T>(collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => any[];
    type LodashMap6x1 = <T>(collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => boolean[];
    interface LodashMapKeys {
        (iteratee: lodash.ValueIteratee<number>): LodashMapKeys1x1;
        <T>(iteratee: lodash.__, object: lodash.List<T> | null | undefined): LodashMapKeys1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<number>, object: lodash.List<T> | null | undefined): lodash.Dictionary<T>;
        (iteratee: lodash.ValueIteratee<string>): LodashMapKeys2x1;
        <T extends object>(iteratee: lodash.__, object: T | null | undefined): LodashMapKeys2x2<T>;
        <T extends object>(iteratee: lodash.ValueIteratee<string>, object: T | null | undefined): lodash.Dictionary<T[keyof T]>;
    }
    type LodashMapKeys1x1 = <T>(object: lodash.List<T> | null | undefined) => lodash.Dictionary<T>;
    type LodashMapKeys1x2<T> = (iteratee: lodash.ValueIteratee<number>) => lodash.Dictionary<T>;
    type LodashMapKeys2x1 = <T extends object>(object: T | null | undefined) => lodash.Dictionary<T[keyof T]>;
    type LodashMapKeys2x2<T> = (iteratee: lodash.ValueIteratee<string>) => lodash.Dictionary<T[keyof T]>;
    interface LodashMapValues {
        <T, TResult>(callback: (value: T) => TResult): LodashMapValues1x1<T, TResult>;
        <T>(callbackOrIterateeOrIterateeOrIteratee: lodash.__, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashMapValues1x2<T>;
        <T, TResult>(callback: (value: T) => TResult, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<TResult>;
        <T extends object, TResult>(callback: (value: T[keyof T]) => TResult): LodashMapValues2x1<T, TResult>;
        <T extends object>(callbackOrIterateeOrIteratee: lodash.__, obj: T | null | undefined): LodashMapValues2x2<T>;
        <T extends object, TResult>(callback: (value: T[keyof T]) => TResult, obj: T | null | undefined): { [P in keyof T]: TResult };
        (iteratee: object): LodashMapValues3x1;
        <T>(iteratee: object, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<boolean>;
        <T extends object>(iteratee: object, obj: T | null | undefined): { [P in keyof T]: boolean };
        <T, TKey extends keyof T>(iteratee: TKey): LodashMapValues5x1<T, TKey>;
        <T, TKey extends keyof T>(iteratee: TKey, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<T[TKey]>;
        (iteratee: string): LodashMapValues6x1;
        <T>(iteratee: string, obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<any>;
        <T extends object>(iteratee: string, obj: T | null | undefined): { [P in keyof T]: any };
    }
    type LodashMapValues1x1<T, TResult> = (obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => lodash.Dictionary<TResult>;
    interface LodashMapValues1x2<T> {
        <TResult>(callback: (value: T) => TResult): lodash.Dictionary<TResult>;
        (iteratee: object): lodash.Dictionary<boolean>;
        <TKey extends keyof T>(iteratee: TKey): lodash.Dictionary<T[TKey]>;
        (iteratee: string): lodash.Dictionary<any>;
    }
    type LodashMapValues2x1<T, TResult> = (obj: T | null | undefined) => { [P in keyof T]: TResult };
    interface LodashMapValues2x2<T> {
        <TResult>(callback: (value: T[keyof T]) => TResult): { [P in keyof T]: TResult };
        (iteratee: object): { [P in keyof T]: boolean };
        (iteratee: string): { [P in keyof T]: any };
    }
    interface LodashMapValues3x1 {
        <T>(obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<boolean>;
        <T extends object>(obj: T | null | undefined): { [P in keyof T]: boolean };
    }
    type LodashMapValues5x1<T, TKey extends keyof T> = (obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined) => lodash.Dictionary<T[TKey]>;
    interface LodashMapValues6x1 {
        <T>(obj: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): lodash.Dictionary<any>;
        <T extends object>(obj: T | null | undefined): { [P in keyof T]: any };
    }
    interface LodashMatchesProperty {
        (path: lodash.PropertyPath): LodashMatchesProperty1x1;
        <T>(path: lodash.__, srcValue: T): LodashMatchesProperty1x2;
        <T>(path: lodash.PropertyPath, srcValue: T): (value: any) => boolean;
    }
    type LodashMatchesProperty1x1 = <T>(srcValue: T) => (value: any) => boolean;
    type LodashMatchesProperty1x2 = (path: lodash.PropertyPath) => (value: any) => boolean;
    type LodashMax = <T>(collection: lodash.List<T> | null | undefined) => T | undefined;
    interface LodashMaxBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashMaxBy1x1<T>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMaxBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): T | undefined;
    }
    type LodashMaxBy1x1<T> = (collection: lodash.List<T> | null | undefined) => T | undefined;
    type LodashMaxBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T | undefined;
    type LodashMean = (collection: lodash.List<any> | null | undefined) => number;
    interface LodashMeanBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashMeanBy1x1<T>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMeanBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): number;
    }
    type LodashMeanBy1x1<T> = (collection: lodash.List<T> | null | undefined) => number;
    type LodashMeanBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => number;
    type LodashMemoize = <T extends (...args: any) => any>(func: T) => T & lodash.MemoizedFunction;
    interface LodashMerge {
        <TObject>(object: TObject): LodashMerge1x1<TObject>;
        <TSource>(object: lodash.__, source: TSource): LodashMerge1x2<TSource>;
        <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
    }
    type LodashMerge1x1<TObject> = <TSource>(source: TSource) => TObject & TSource;
    type LodashMerge1x2<TSource> = <TObject>(object: TObject) => TObject & TSource;
    interface LodashMergeAll {
        <TObject, TSource>(object: [TObject, TSource]): TObject & TSource;
        <TObject, TSource1, TSource2>(object: [TObject, TSource1, TSource2]): TObject & TSource1 & TSource2;
        <TObject, TSource1, TSource2, TSource3>(object: [TObject, TSource1, TSource2, TSource3]): TObject & TSource1 & TSource2 & TSource3;
        <TObject, TSource1, TSource2, TSource3, TSource4>(object: [TObject, TSource1, TSource2, TSource3, TSource4]): TObject & TSource1 & TSource2 & TSource3 & TSource4;
        (object: readonly any[]): any;
    }
    interface LodashMergeAllWith {
        (customizer: lodash.MergeWithCustomizer): LodashMergeAllWith1x1;
        (customizer: lodash.__, args: readonly any[]): LodashMergeAllWith1x2;
        (customizer: lodash.MergeWithCustomizer, args: readonly any[]): any;
    }
    type LodashMergeAllWith1x1 = (args: readonly any[]) => any;
    type LodashMergeAllWith1x2 = (customizer: lodash.MergeWithCustomizer) => any;
    interface LodashMergeWith {
        (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x1;
        <TObject>(customizer: lodash.__, object: TObject): LodashMergeWith1x2<TObject>;
        <TObject>(customizer: lodash.MergeWithCustomizer, object: TObject): LodashMergeWith1x3<TObject>;
        <TSource>(customizer: lodash.__, object: lodash.__, source: TSource): LodashMergeWith1x4<TSource>;
        <TSource>(customizer: lodash.MergeWithCustomizer, object: lodash.__, source: TSource): LodashMergeWith1x5<TSource>;
        <TObject, TSource>(customizer: lodash.__, object: TObject, source: TSource): LodashMergeWith1x6<TObject, TSource>;
        <TObject, TSource>(customizer: lodash.MergeWithCustomizer, object: TObject, source: TSource): TObject & TSource;
    }
    interface LodashMergeWith1x1 {
        <TObject>(object: TObject): LodashMergeWith1x3<TObject>;
        <TSource>(object: lodash.__, source: TSource): LodashMergeWith1x5<TSource>;
        <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
    }
    interface LodashMergeWith1x2<TObject> {
        (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x3<TObject>;
        <TSource>(customizer: lodash.__, source: TSource): LodashMergeWith1x6<TObject, TSource>;
        <TSource>(customizer: lodash.MergeWithCustomizer, source: TSource): TObject & TSource;
    }
    type LodashMergeWith1x3<TObject> = <TSource>(source: TSource) => TObject & TSource;
    interface LodashMergeWith1x4<TSource> {
        (customizer: lodash.MergeWithCustomizer): LodashMergeWith1x5<TSource>;
        <TObject>(customizer: lodash.__, object: TObject): LodashMergeWith1x6<TObject, TSource>;
        <TObject>(customizer: lodash.MergeWithCustomizer, object: TObject): TObject & TSource;
    }
    type LodashMergeWith1x5<TSource> = <TObject>(object: TObject) => TObject & TSource;
    type LodashMergeWith1x6<TObject, TSource> = (customizer: lodash.MergeWithCustomizer) => TObject & TSource;
    type LodashMethod = (path: lodash.PropertyPath) => (object: any) => any;
    type LodashMethodOf = (object: object) => (path: lodash.PropertyPath) => any;
    type LodashMin = <T>(collection: lodash.List<T> | null | undefined) => T | undefined;
    interface LodashMinBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashMinBy1x1<T>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashMinBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): T | undefined;
    }
    type LodashMinBy1x1<T> = (collection: lodash.List<T> | null | undefined) => T | undefined;
    type LodashMinBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T | undefined;
    interface LodashMultiply {
        (multiplier: number): LodashMultiply1x1;
        (multiplier: lodash.__, multiplicand: number): LodashMultiply1x2;
        (multiplier: number, multiplicand: number): number;
    }
    type LodashMultiply1x1 = (multiplicand: number) => number;
    type LodashMultiply1x2 = (multiplier: number) => number;
    type LodashNoConflict = () => typeof _;
    type LodashNoop = (...args: any[]) => void;
    type LodashNow = () => number;
    interface LodashNth {
        (n: number): LodashNth1x1;
        <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashNth1x2<T>;
        <T>(n: number, array: lodash.List<T> | null | undefined): T | undefined;
    }
    type LodashNth1x1 = <T>(array: lodash.List<T> | null | undefined) => T | undefined;
    type LodashNth1x2<T> = (n: number) => T | undefined;
    type LodashNthArg = (n: number) => (...args: any[]) => any;
    interface LodashOmit {
        <T extends object, K extends keyof T>(paths: lodash.Many<K>): LodashOmit1x1<T, K>;
        <T extends object>(paths: lodash.__, object: T | null | undefined): LodashOmit1x2<T>;
        <T extends object, K extends keyof T>(paths: lodash.Many<K>, object: T | null | undefined): lodash.Omit<T, K>;
        (paths: lodash.Many<lodash.PropertyName>): LodashOmit2x1;
        <T extends object>(paths: lodash.Many<lodash.PropertyName>, object: T | null | undefined): lodash.PartialObject<T>;
    }
    type LodashOmit1x1<T, K extends keyof T> = (object: T | null | undefined) => lodash.Omit<T, K>;
    interface LodashOmit1x2<T> {
        <K extends keyof T>(paths: lodash.Many<K>): lodash.Omit<T, K>;
        (paths: lodash.Many<lodash.PropertyName>): lodash.PartialObject<T>;
    }
    type LodashOmit2x1 = <T extends object>(object: T | null | undefined) => lodash.PartialObject<T>;
    interface LodashOmitBy {
        <T>(predicate: lodash.ValueKeyIteratee<T>): LodashOmitBy1x1<T>;
        <T>(predicate: lodash.__, object: lodash.Dictionary<T> | null | undefined): LodashOmitBy1x2<T>;
        <T>(predicate: lodash.ValueKeyIteratee<T>, object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<T>;
        <T>(predicate: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashOmitBy2x2<T>;
        <T>(predicate: lodash.ValueKeyIteratee<T>, object: lodash.NumericDictionary<T> | null | undefined): lodash.NumericDictionary<T>;
        <T extends object>(predicate: lodash.__, object: T | null | undefined): LodashOmitBy3x2<T>;
        <T extends object>(predicate: lodash.ValueKeyIteratee<T[keyof T]>, object: T | null | undefined): lodash.PartialObject<T>;
    }
    interface LodashOmitBy1x1<T> {
        (object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<T>;
        (object: lodash.NumericDictionary<T> | null | undefined): lodash.NumericDictionary<T>;
        <T1 extends object>(object: T1 | null | undefined): lodash.PartialObject<T1>;
    }
    type LodashOmitBy1x2<T> = (predicate: lodash.ValueKeyIteratee<T>) => lodash.Dictionary<T>;
    type LodashOmitBy2x2<T> = (predicate: lodash.ValueKeyIteratee<T>) => lodash.NumericDictionary<T>;
    type LodashOmitBy3x2<T> = (predicate: lodash.ValueKeyIteratee<T[keyof T]>) => lodash.PartialObject<T>;
    type LodashOnce = <T extends (...args: any) => any>(func: T) => T;
    interface LodashOrderBy {
        <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x1<T>;
        (iteratees: lodash.__, orders: lodash.Many<boolean|"asc"|"desc">): LodashOrderBy1x2;
        <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid>, orders: lodash.Many<boolean|"asc"|"desc">): LodashOrderBy1x3<T>;
        <T>(iteratees: lodash.__, orders: lodash.__, collection: lodash.List<T> | null | undefined): LodashOrderBy1x4<T>;
        <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid>, orders: lodash.__, collection: lodash.List<T> | null | undefined): LodashOrderBy1x5<T>;
        <T>(iteratees: lodash.__, orders: lodash.Many<boolean|"asc"|"desc">, collection: lodash.List<T> | null | undefined): LodashOrderBy1x6<T>;
        <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T>>, orders: lodash.Many<boolean | "asc" | "desc">, collection: lodash.List<T> | null | undefined): T[];
        <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>): LodashOrderBy2x1<T>;
        <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>, orders: lodash.Many<boolean|"asc"|"desc">): LodashOrderBy2x3<T>;
        <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>, orders: lodash.__, collection: lodash.List<T> | null | undefined): LodashOrderBy2x5<T>;
        <T extends object>(iteratees: lodash.__, orders: lodash.__, collection: T | null | undefined): LodashOrderBy3x4<T>;
        <T extends object>(iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid>, orders: lodash.__, collection: T | null | undefined): LodashOrderBy3x5<T>;
        <T extends object>(iteratees: lodash.__, orders: lodash.Many<boolean|"asc"|"desc">, collection: T | null | undefined): LodashOrderBy3x6<T>;
        <T extends object>(iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T[keyof T]>>, orders: lodash.Many<boolean | "asc" | "desc">, collection: T | null | undefined): Array<T[keyof T]>;
        <T extends object>(iteratees: lodash.Many<lodash.ValueIteratee<T[keyof T]>>, orders: lodash.__, collection: T | null | undefined): LodashOrderBy4x5<T>;
    }
    interface LodashOrderBy1x1<T> {
        (orders: lodash.Many<boolean | "asc" | "desc">): LodashOrderBy1x3<T>;
        (orders: lodash.__, collection: lodash.List<T> | null | undefined): LodashOrderBy1x5<T>;
        (orders: lodash.Many<boolean | "asc" | "desc">, collection: lodash.List<T> | object | null | undefined): T[];
        <T1 extends object>(orders: lodash.__, collection: T1 | null | undefined): LodashOrderBy3x5<T>;
    }
    interface LodashOrderBy1x2 {
        <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x3<T>;
        <T>(iteratees: lodash.__, collection: lodash.List<T> | null | undefined): LodashOrderBy1x6<T>;
        <T>(iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T>>, collection: lodash.List<T> | null | undefined): T[];
        <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>): LodashOrderBy2x3<T>;
        <T extends object>(iteratees: lodash.__, collection: T | null | undefined): LodashOrderBy3x6<T>;
        <T extends object>(iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T[keyof T]>>, collection: T | null | undefined): Array<T[keyof T]>;
    }
    interface LodashOrderBy1x3<T> {
        (collection: lodash.List<T> | null | undefined): T[];
        (collection: object | null | undefined): object[];
    }
    interface LodashOrderBy1x4<T> {
        (iteratees: lodash.Many<(value: T) => lodash.NotVoid>): LodashOrderBy1x5<T>;
        (iteratees: lodash.__, orders: lodash.Many<boolean | "asc" | "desc">): LodashOrderBy1x6<T>;
        (iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T>>, orders: lodash.Many<boolean | "asc" | "desc">): T[];
        (iteratees: lodash.Many<lodash.ValueIteratee<T>>): LodashOrderBy2x5<T>;
    }
    type LodashOrderBy1x5<T> = (orders: lodash.Many<boolean|"asc"|"desc">) => T[];
    type LodashOrderBy1x6<T> = (iteratees: lodash.Many<(value: T) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T>>) => T[];
    interface LodashOrderBy2x1<T> {
        (orders: lodash.Many<boolean | "asc" | "desc">): LodashOrderBy2x3<T>;
        (orders: lodash.__, collection: lodash.List<T> | null | undefined): LodashOrderBy2x5<T>;
        (orders: lodash.Many<boolean | "asc" | "desc">, collection: lodash.List<T> | object | null | undefined): T[];
        <T1 extends object>(orders: lodash.__, collection: T1 | null | undefined): LodashOrderBy4x5<T>;
    }
    interface LodashOrderBy2x3<T> {
        (collection: lodash.List<T> | null | undefined): T[];
        (collection: object | null | undefined): object[];
    }
    type LodashOrderBy2x5<T> = (orders: lodash.Many<boolean|"asc"|"desc">) => T[];
    interface LodashOrderBy3x4<T> {
        (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid>): LodashOrderBy3x5<T>;
        (iteratees: lodash.__, orders: lodash.Many<boolean | "asc" | "desc">): LodashOrderBy3x6<T>;
        (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T[keyof T]>>, orders: lodash.Many<boolean | "asc" | "desc">): Array<T[keyof T]>;
        (iteratees: lodash.Many<lodash.ValueIteratee<T[keyof T]>>): LodashOrderBy4x5<T>;
    }
    type LodashOrderBy3x5<T> = (orders: lodash.Many<boolean|"asc"|"desc">) => Array<T[keyof T]>;
    type LodashOrderBy3x6<T> = (iteratees: lodash.Many<(value: T[keyof T]) => lodash.NotVoid> | lodash.Many<lodash.ValueIteratee<T[keyof T]>>) => Array<T[keyof T]>;
    type LodashOrderBy4x5<T> = (orders: lodash.Many<boolean|"asc"|"desc">) => Array<T[keyof T]>;
    interface LodashOverArgs {
        (func: (...args: any[]) => any): LodashOverArgs1x1;
        (func: lodash.__, transforms: lodash.Many<(...args: any[]) => any>): LodashOverArgs1x2;
        (func: (...args: any[]) => any, transforms: lodash.Many<(...args: any[]) => any>): (...args: any[]) => any;
    }
    type LodashOverArgs1x1 = (transforms: lodash.Many<(...args: any[]) => any>) => (...args: any[]) => any;
    type LodashOverArgs1x2 = (func: (...args: any[]) => any) => (...args: any[]) => any;
    interface LodashPad {
        (length: number): LodashPad1x1;
        (length: lodash.__, string: string): LodashPad1x2;
        (length: number, string: string): string;
    }
    type LodashPad1x1 = (string: string) => string;
    type LodashPad1x2 = (length: number) => string;
    interface LodashPadChars {
        (chars: string): LodashPadChars1x1;
        (chars: lodash.__, length: number): LodashPadChars1x2;
        (chars: string, length: number): LodashPadChars1x3;
        (chars: lodash.__, length: lodash.__, string: string): LodashPadChars1x4;
        (chars: string, length: lodash.__, string: string): LodashPadChars1x5;
        (chars: lodash.__, length: number, string: string): LodashPadChars1x6;
        (chars: string, length: number, string: string): string;
    }
    interface LodashPadChars1x1 {
        (length: number): LodashPadChars1x3;
        (length: lodash.__, string: string): LodashPadChars1x5;
        (length: number, string: string): string;
    }
    interface LodashPadChars1x2 {
        (chars: string): LodashPadChars1x3;
        (chars: lodash.__, string: string): LodashPadChars1x6;
        (chars: string, string: string): string;
    }
    type LodashPadChars1x3 = (string: string) => string;
    interface LodashPadChars1x4 {
        (chars: string): LodashPadChars1x5;
        (chars: lodash.__, length: number): LodashPadChars1x6;
        (chars: string, length: number): string;
    }
    type LodashPadChars1x5 = (length: number) => string;
    type LodashPadChars1x6 = (chars: string) => string;
    interface LodashPadCharsEnd {
        (chars: string): LodashPadCharsEnd1x1;
        (chars: lodash.__, length: number): LodashPadCharsEnd1x2;
        (chars: string, length: number): LodashPadCharsEnd1x3;
        (chars: lodash.__, length: lodash.__, string: string): LodashPadCharsEnd1x4;
        (chars: string, length: lodash.__, string: string): LodashPadCharsEnd1x5;
        (chars: lodash.__, length: number, string: string): LodashPadCharsEnd1x6;
        (chars: string, length: number, string: string): string;
    }
    interface LodashPadCharsEnd1x1 {
        (length: number): LodashPadCharsEnd1x3;
        (length: lodash.__, string: string): LodashPadCharsEnd1x5;
        (length: number, string: string): string;
    }
    interface LodashPadCharsEnd1x2 {
        (chars: string): LodashPadCharsEnd1x3;
        (chars: lodash.__, string: string): LodashPadCharsEnd1x6;
        (chars: string, string: string): string;
    }
    type LodashPadCharsEnd1x3 = (string: string) => string;
    interface LodashPadCharsEnd1x4 {
        (chars: string): LodashPadCharsEnd1x5;
        (chars: lodash.__, length: number): LodashPadCharsEnd1x6;
        (chars: string, length: number): string;
    }
    type LodashPadCharsEnd1x5 = (length: number) => string;
    type LodashPadCharsEnd1x6 = (chars: string) => string;
    interface LodashPadCharsStart {
        (chars: string): LodashPadCharsStart1x1;
        (chars: lodash.__, length: number): LodashPadCharsStart1x2;
        (chars: string, length: number): LodashPadCharsStart1x3;
        (chars: lodash.__, length: lodash.__, string: string): LodashPadCharsStart1x4;
        (chars: string, length: lodash.__, string: string): LodashPadCharsStart1x5;
        (chars: lodash.__, length: number, string: string): LodashPadCharsStart1x6;
        (chars: string, length: number, string: string): string;
    }
    interface LodashPadCharsStart1x1 {
        (length: number): LodashPadCharsStart1x3;
        (length: lodash.__, string: string): LodashPadCharsStart1x5;
        (length: number, string: string): string;
    }
    interface LodashPadCharsStart1x2 {
        (chars: string): LodashPadCharsStart1x3;
        (chars: lodash.__, string: string): LodashPadCharsStart1x6;
        (chars: string, string: string): string;
    }
    type LodashPadCharsStart1x3 = (string: string) => string;
    interface LodashPadCharsStart1x4 {
        (chars: string): LodashPadCharsStart1x5;
        (chars: lodash.__, length: number): LodashPadCharsStart1x6;
        (chars: string, length: number): string;
    }
    type LodashPadCharsStart1x5 = (length: number) => string;
    type LodashPadCharsStart1x6 = (chars: string) => string;
    interface LodashPadEnd {
        (length: number): LodashPadEnd1x1;
        (length: lodash.__, string: string): LodashPadEnd1x2;
        (length: number, string: string): string;
    }
    type LodashPadEnd1x1 = (string: string) => string;
    type LodashPadEnd1x2 = (length: number) => string;
    interface LodashPadStart {
        (length: number): LodashPadStart1x1;
        (length: lodash.__, string: string): LodashPadStart1x2;
        (length: number, string: string): string;
    }
    type LodashPadStart1x1 = (string: string) => string;
    type LodashPadStart1x2 = (length: number) => string;
    interface LodashParseInt {
        (radix: number): LodashParseInt1x1;
        (radix: lodash.__, string: string): LodashParseInt1x2;
        (radix: number, string: string): number;
    }
    type LodashParseInt1x1 = (string: string) => number;
    type LodashParseInt1x2 = (radix: number) => number;
    interface LodashPartial {
        <T1, T2, R>(func: lodash.Function2<T1, T2, R>): LodashPartial1x1<T1, T2, R>;
        <T2>(func: lodash.__, plc1: [lodash.__, T2]): LodashPartial1x2<T2>;
        <T1, T2, R>(func: lodash.Function2<T1, T2, R>, plc1: [lodash.__, T2]): lodash.Function1<T1, R>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>): LodashPartial2x1<T1, T2, T3, R>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, plc1: [lodash.__, T2]): lodash.Function2<T1, T3, R>;
        <T3>(func: lodash.__, plc1: [lodash.__, lodash.__, T3]): LodashPartial3x2<T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, plc1: [lodash.__, lodash.__, T3]): lodash.Function2<T1, T2, R>;
        <T1, T3>(func: lodash.__, arg1: [T1, lodash.__, T3]): LodashPartial4x2<T1, T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg1: [T1, lodash.__, T3]): lodash.Function1<T2, R>;
        <T2, T3>(func: lodash.__, plc1: [lodash.__, T2, T3]): LodashPartial5x2<T2, T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, plc1: [lodash.__, T2, T3]): lodash.Function1<T1, R>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): LodashPartial6x1<T1, T2, T3, T4, R>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, T2]): lodash.Function3<T1, T3, T4, R>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, lodash.__, T3]): lodash.Function3<T1, T2, T4, R>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, T3]): lodash.Function2<T2, T4, R>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, T2, T3]): lodash.Function2<T1, T4, R>;
        <T1, T2, T3>(func: lodash.__, arg1OrT1: [T1, T2, T3]): LodashPartial10x2<T1, T2, T3>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, T2, T3]): lodash.Function1<T4, R>;
        <T4>(func: lodash.__, plc1: [lodash.__, lodash.__, lodash.__, T4]): LodashPartial11x2<T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, lodash.__, lodash.__, T4]): lodash.Function3<T1, T2, T3, R>;
        <T1, T4>(func: lodash.__, arg1: [T1, lodash.__, lodash.__, T4]): LodashPartial12x2<T1, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2<T2, T3, R>;
        <T2, T4>(func: lodash.__, plc1: [lodash.__, T2, lodash.__, T4]): LodashPartial13x2<T2, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, T2, lodash.__, T4]): lodash.Function2<T1, T3, R>;
        <T1, T2, T4>(func: lodash.__, arg1: [T1, T2, lodash.__, T4]): LodashPartial14x2<T1, T2, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, T2, lodash.__, T4]): lodash.Function1<T3, R>;
        <T3, T4>(func: lodash.__, plc1: [lodash.__, lodash.__, T3, T4]): LodashPartial15x2<T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, lodash.__, T3, T4]): lodash.Function2<T1, T2, R>;
        <T1, T3, T4>(func: lodash.__, arg1: [T1, lodash.__, T3, T4]): LodashPartial16x2<T1, T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, T3, T4]): lodash.Function1<T2, R>;
        <T2, T3, T4>(func: lodash.__, plc1: [lodash.__, T2, T3, T4]): LodashPartial17x2<T2, T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, plc1: [lodash.__, T2, T3, T4]): lodash.Function1<T1, R>;
        <TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R): LodashPartial18x1<TS, T1, R>;
        <T1>(func: lodash.__, arg1: [T1]): LodashPartial18x2<T1>;
        <TS extends any[], T1, R>(func: (t1: T1, ...ts: TS) => R, arg1: [T1]): (...ts: TS) => R;
        <TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R): LodashPartial19x1<TS, T1, T2, R>;
        <T1, T2>(func: lodash.__, t1: [T1, T2]): LodashPartial19x2<T1, T2>;
        <TS extends any[], T1, T2, R>(func: (t1: T1, t2: T2, ...ts: TS) => R, t1: [T1, T2]): (...ts: TS) => R;
        <TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R): LodashPartial20x1<TS, T1, T2, T3, R>;
        <TS extends any[], T1, T2, T3, R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R, t1: [T1, T2, T3]): (...ts: TS) => R;
        <TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R): LodashPartial21x1<TS, T1, T2, T3, T4, R>;
        <T1, T2, T3, T4>(func: lodash.__, t1: [T1, T2, T3, T4]): LodashPartial21x2<T1, T2, T3, T4>;
        <TS extends any[], T1, T2, T3, T4, R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R, t1: [T1, T2, T3, T4]): (...ts: TS) => R;
        placeholder: lodash.__;
    }
    type LodashPartial1x1<T1, T2, R> = (plc1: [lodash.__, T2]) => lodash.Function1<T1, R>;
    interface LodashPartial1x2<T2> {
        <T1, R>(func: lodash.Function2<T1, T2, R>): lodash.Function1<T1, R>;
        <T1, T3, R>(func: lodash.Function3<T1, T2, T3, R>): lodash.Function2<T1, T3, R>;
        <T1, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): lodash.Function3<T1, T3, T4, R>;
    }
    interface LodashPartial2x1<T1, T2, T3, R> {
        (plc1: [lodash.__, T2]): lodash.Function2<T1, T3, R>;
        (plc1: [lodash.__, lodash.__, T3]): lodash.Function2<T1, T2, R>;
        (arg1: [T1, lodash.__, T3]): lodash.Function1<T2, R>;
        (plc1: [lodash.__, T2, T3]): lodash.Function1<T1, R>;
    }
    interface LodashPartial3x2<T3> {
        <T1, T2, R>(func: lodash.Function3<T1, T2, T3, R>): lodash.Function2<T1, T2, R>;
        <T1, T2, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): lodash.Function3<T1, T2, T4, R>;
    }
    interface LodashPartial4x2<T1, T3> {
        <T2, R>(func: lodash.Function3<T1, T2, T3, R>): lodash.Function1<T2, R>;
        <T2, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): lodash.Function2<T2, T4, R>;
    }
    interface LodashPartial5x2<T2, T3> {
        <T1, R>(func: lodash.Function3<T1, T2, T3, R>): lodash.Function1<T1, R>;
        <T1, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): lodash.Function2<T1, T4, R>;
    }
    interface LodashPartial6x1<T1, T2, T3, T4, R> {
        (plc1: [lodash.__, T2]): lodash.Function3<T1, T3, T4, R>;
        (plc1: [lodash.__, lodash.__, T3]): lodash.Function3<T1, T2, T4, R>;
        (arg1: [T1, lodash.__, T3]): lodash.Function2<T2, T4, R>;
        (plc1: [lodash.__, T2, T3]): lodash.Function2<T1, T4, R>;
        (arg1: [T1, T2, T3]): lodash.Function1<T4, R>;
        (plc1: [lodash.__, lodash.__, lodash.__, T4]): lodash.Function3<T1, T2, T3, R>;
        (arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2<T2, T3, R>;
        (plc1: [lodash.__, T2, lodash.__, T4]): lodash.Function2<T1, T3, R>;
        (arg1: [T1, T2, lodash.__, T4]): lodash.Function1<T3, R>;
        (plc1: [lodash.__, lodash.__, T3, T4]): lodash.Function2<T1, T2, R>;
        (arg1: [T1, lodash.__, T3, T4]): lodash.Function1<T2, R>;
        (plc1: [lodash.__, T2, T3, T4]): lodash.Function1<T1, R>;
    }
    interface LodashPartial10x2<T1, T2, T3> {
        <T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): lodash.Function1<T4, R>;
        <TS extends any[], R>(func: (t1: T1, t2: T2, t3: T3, ...ts: TS) => R): (...ts: TS) => R;
    }
    type LodashPartial11x2<T4> = <T1, T2, T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function3<T1, T2, T3, R>;
    type LodashPartial12x2<T1, T4> = <T2, T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T2, T3, R>;
    type LodashPartial13x2<T2, T4> = <T1, T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T1, T3, R>;
    type LodashPartial14x2<T1, T2, T4> = <T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T3, R>;
    type LodashPartial15x2<T3, T4> = <T1, T2, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T1, T2, R>;
    type LodashPartial16x2<T1, T3, T4> = <T2, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T2, R>;
    type LodashPartial17x2<T2, T3, T4> = <T1, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T1, R>;
    type LodashPartial18x1<TS extends any[], T1, R> = (arg1: [T1]) => (...ts: TS) => R;
    type LodashPartial18x2<T1> = <TS extends any[], R>(func: (t1: T1, ...ts: TS) => R) => (...ts: TS) => R;
    type LodashPartial19x1<TS extends any[], T1, T2, R> = (t1: [T1, T2]) => (...ts: TS) => R;
    type LodashPartial19x2<T1, T2> = <TS extends any[], R>(func: (t1: T1, t2: T2, ...ts: TS) => R) => (...ts: TS) => R;
    type LodashPartial20x1<TS extends any[], T1, T2, T3, R> = (t1: [T1, T2, T3]) => (...ts: TS) => R;
    type LodashPartial21x1<TS extends any[], T1, T2, T3, T4, R> = (t1: [T1, T2, T3, T4]) => (...ts: TS) => R;
    type LodashPartial21x2<T1, T2, T3, T4> = <TS extends any[], R>(func: (t1: T1, t2: T2, t3: T3, t4: T4, ...ts: TS) => R) => (...ts: TS) => R;
    interface LodashPartialRight {
        <T1, R>(func: lodash.Function1<T1, R>): LodashPartialRight1x1<T1, R>;
        <T1>(func: lodash.__, arg1: [T1]): LodashPartialRight1x2<T1>;
        <T1, R>(func: lodash.Function1<T1, R>, arg1: [T1]): lodash.Function0<R>;
        <T1, T2, R>(func: lodash.Function2<T1, T2, R>): LodashPartialRight2x1<T1, T2, R>;
        <T1>(func: lodash.__, arg1: [T1, lodash.__]): LodashPartialRight2x2<T1>;
        <T1, T2, R>(func: lodash.Function2<T1, T2, R>, arg1: [T1, lodash.__]): lodash.Function1<T2, R>;
        <T2>(func: lodash.__, arg2: [T2]): LodashPartialRight3x2<T2>;
        <T1, T2, R>(func: lodash.Function2<T1, T2, R>, arg2: [T2]): lodash.Function1<T1, R>;
        <T1, T2>(func: lodash.__, arg1: [T1, T2]): LodashPartialRight4x2<T1, T2>;
        <T1, T2, R>(func: lodash.Function2<T1, T2, R>, arg1: [T1, T2]): lodash.Function0<R>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>): LodashPartialRight5x1<T1, T2, T3, R>;
        <T1>(func: lodash.__, arg1: [T1, lodash.__, lodash.__]): LodashPartialRight5x2<T1>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg1: [T1, lodash.__, lodash.__]): lodash.Function2<T2, T3, R>;
        <T2>(func: lodash.__, arg2: [T2, lodash.__]): LodashPartialRight6x2<T2>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg2: [T2, lodash.__]): lodash.Function2<T1, T3, R>;
        <T1, T2>(func: lodash.__, arg1: [T1, T2, lodash.__]): LodashPartialRight7x2<T1, T2>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg1: [T1, T2, lodash.__]): lodash.Function1<T3, R>;
        <T3>(func: lodash.__, arg3: [T3]): LodashPartialRight8x2<T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg3: [T3]): lodash.Function2<T1, T2, R>;
        <T1, T3>(func: lodash.__, arg1: [T1, lodash.__, T3]): LodashPartialRight9x2<T1, T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg1: [T1, lodash.__, T3]): lodash.Function1<T2, R>;
        <T2, T3>(func: lodash.__, arg2: [T2, T3]): LodashPartialRight10x2<T2, T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg2: [T2, T3]): lodash.Function1<T1, R>;
        <T1, T2, T3>(func: lodash.__, arg1: [T1, T2, T3]): LodashPartialRight11x2<T1, T2, T3>;
        <T1, T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>, arg1: [T1, T2, T3]): lodash.Function0<R>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>): LodashPartialRight12x1<T1, T2, T3, T4, R>;
        <T1>(func: lodash.__, arg1: [T1, lodash.__, lodash.__, lodash.__]): LodashPartialRight12x2<T1>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, lodash.__, lodash.__]): lodash.Function3<T2, T3, T4, R>;
        <T2>(func: lodash.__, arg2: [T2, lodash.__, lodash.__]): LodashPartialRight13x2<T2>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg2: [T2, lodash.__, lodash.__]): lodash.Function3<T1, T3, T4, R>;
        <T1, T2>(func: lodash.__, arg1: [T1, T2, lodash.__, lodash.__]): LodashPartialRight14x2<T1, T2>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, T2, lodash.__, lodash.__]): lodash.Function2<T3, T4, R>;
        <T3>(func: lodash.__, arg3: [T3, lodash.__]): LodashPartialRight15x2<T3>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg3: [T3, lodash.__]): lodash.Function3<T1, T2, T4, R>;
        <T1, T3>(func: lodash.__, arg1: [T1, lodash.__, T3, lodash.__]): LodashPartialRight16x2<T1, T3>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, T3, lodash.__]): lodash.Function2<T2, T4, R>;
        <T2, T3>(func: lodash.__, arg2: [T2, T3, lodash.__]): LodashPartialRight17x2<T2, T3>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg2: [T2, T3, lodash.__]): lodash.Function2<T1, T4, R>;
        <T1, T2, T3>(func: lodash.__, arg1: [T1, T2, T3, lodash.__]): LodashPartialRight18x2<T1, T2, T3>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, T2, T3, lodash.__]): lodash.Function1<T4, R>;
        <T4>(func: lodash.__, arg4: [T4]): LodashPartialRight19x2<T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg4: [T4]): lodash.Function3<T1, T2, T3, R>;
        <T1, T4>(func: lodash.__, arg1: [T1, lodash.__, lodash.__, T4]): LodashPartialRight20x2<T1, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2<T2, T3, R>;
        <T2, T4>(func: lodash.__, arg2: [T2, lodash.__, T4]): LodashPartialRight21x2<T2, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg2: [T2, lodash.__, T4]): lodash.Function2<T1, T3, R>;
        <T1, T2, T4>(func: lodash.__, arg1: [T1, T2, lodash.__, T4]): LodashPartialRight22x2<T1, T2, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, T2, lodash.__, T4]): lodash.Function1<T3, R>;
        <T3, T4>(func: lodash.__, arg3: [T3, T4]): LodashPartialRight23x2<T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg3: [T3, T4]): lodash.Function2<T1, T2, R>;
        <T1, T3, T4>(func: lodash.__, arg1: [T1, lodash.__, T3, T4]): LodashPartialRight24x2<T1, T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, lodash.__, T3, T4]): lodash.Function1<T2, R>;
        <T2, T3, T4>(func: lodash.__, arg2: [T2, T3, T4]): LodashPartialRight25x2<T2, T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg2: [T2, T3, T4]): lodash.Function1<T1, R>;
        <T1, T2, T3, T4>(func: lodash.__, arg1: [T1, T2, T3, T4]): LodashPartialRight26x2<T1, T2, T3, T4>;
        <T1, T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>, arg1: [T1, T2, T3, T4]): lodash.Function0<R>;
        (func: (...args: any[]) => any): LodashPartialRight27x1;
        (func: lodash.__, args: readonly any[]): LodashPartialRight27x2;
        (func: (...args: any[]) => any, args: readonly any[]): (...args: any[]) => any;
        placeholder: lodash.__;
    }
    type LodashPartialRight1x1<T1, R> = (arg1: [T1]) => lodash.Function0<R>;
    type LodashPartialRight1x2<T1> = <R>(func: lodash.Function1<T1, R>) => lodash.Function0<R>;
    interface LodashPartialRight2x1<T1, T2, R> {
        (arg1: [T1, lodash.__]): lodash.Function1<T2, R>;
        (arg2: [T2]): lodash.Function1<T1, R>;
        (arg1: [T1, T2]): lodash.Function0<R>;
    }
    type LodashPartialRight2x2<T1> = <T2, R>(func: lodash.Function2<T1, T2, R>) => lodash.Function1<T2, R>;
    type LodashPartialRight3x2<T2> = <T1, R>(func: lodash.Function2<T1, T2, R>) => lodash.Function1<T1, R>;
    type LodashPartialRight4x2<T1, T2> = <R>(func: lodash.Function2<T1, T2, R>) => lodash.Function0<R>;
    interface LodashPartialRight5x1<T1, T2, T3, R> {
        (arg1: [T1, lodash.__, lodash.__]): lodash.Function2<T2, T3, R>;
        (arg2: [T2, lodash.__]): lodash.Function2<T1, T3, R>;
        (arg1: [T1, T2, lodash.__]): lodash.Function1<T3, R>;
        (arg3: [T3]): lodash.Function2<T1, T2, R>;
        (arg1: [T1, lodash.__, T3]): lodash.Function1<T2, R>;
        (arg2: [T2, T3]): lodash.Function1<T1, R>;
        (arg1: [T1, T2, T3]): lodash.Function0<R>;
    }
    type LodashPartialRight5x2<T1> = <T2, T3, R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function2<T2, T3, R>;
    type LodashPartialRight6x2<T2> = <T1, T3, R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function2<T1, T3, R>;
    type LodashPartialRight7x2<T1, T2> = <T3, R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function1<T3, R>;
    type LodashPartialRight8x2<T3> = <T1, T2, R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function2<T1, T2, R>;
    type LodashPartialRight9x2<T1, T3> = <T2, R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function1<T2, R>;
    type LodashPartialRight10x2<T2, T3> = <T1, R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function1<T1, R>;
    type LodashPartialRight11x2<T1, T2, T3> = <R>(func: lodash.Function3<T1, T2, T3, R>) => lodash.Function0<R>;
    interface LodashPartialRight12x1<T1, T2, T3, T4, R> {
        (arg1: [T1, lodash.__, lodash.__, lodash.__]): lodash.Function3<T2, T3, T4, R>;
        (arg2: [T2, lodash.__, lodash.__]): lodash.Function3<T1, T3, T4, R>;
        (arg1: [T1, T2, lodash.__, lodash.__]): lodash.Function2<T3, T4, R>;
        (arg3: [T3, lodash.__]): lodash.Function3<T1, T2, T4, R>;
        (arg1: [T1, lodash.__, T3, lodash.__]): lodash.Function2<T2, T4, R>;
        (arg2: [T2, T3, lodash.__]): lodash.Function2<T1, T4, R>;
        (arg1: [T1, T2, T3, lodash.__]): lodash.Function1<T4, R>;
        (arg4: [T4]): lodash.Function3<T1, T2, T3, R>;
        (arg1: [T1, lodash.__, lodash.__, T4]): lodash.Function2<T2, T3, R>;
        (arg2: [T2, lodash.__, T4]): lodash.Function2<T1, T3, R>;
        (arg1: [T1, T2, lodash.__, T4]): lodash.Function1<T3, R>;
        (arg3: [T3, T4]): lodash.Function2<T1, T2, R>;
        (arg1: [T1, lodash.__, T3, T4]): lodash.Function1<T2, R>;
        (arg2: [T2, T3, T4]): lodash.Function1<T1, R>;
        (arg1: [T1, T2, T3, T4]): lodash.Function0<R>;
    }
    type LodashPartialRight12x2<T1> = <T2, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function3<T2, T3, T4, R>;
    type LodashPartialRight13x2<T2> = <T1, T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function3<T1, T3, T4, R>;
    type LodashPartialRight14x2<T1, T2> = <T3, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T3, T4, R>;
    type LodashPartialRight15x2<T3> = <T1, T2, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function3<T1, T2, T4, R>;
    type LodashPartialRight16x2<T1, T3> = <T2, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T2, T4, R>;
    type LodashPartialRight17x2<T2, T3> = <T1, T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T1, T4, R>;
    type LodashPartialRight18x2<T1, T2, T3> = <T4, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T4, R>;
    type LodashPartialRight19x2<T4> = <T1, T2, T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function3<T1, T2, T3, R>;
    type LodashPartialRight20x2<T1, T4> = <T2, T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T2, T3, R>;
    type LodashPartialRight21x2<T2, T4> = <T1, T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T1, T3, R>;
    type LodashPartialRight22x2<T1, T2, T4> = <T3, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T3, R>;
    type LodashPartialRight23x2<T3, T4> = <T1, T2, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function2<T1, T2, R>;
    type LodashPartialRight24x2<T1, T3, T4> = <T2, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T2, R>;
    type LodashPartialRight25x2<T2, T3, T4> = <T1, R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function1<T1, R>;
    type LodashPartialRight26x2<T1, T2, T3, T4> = <R>(func: lodash.Function4<T1, T2, T3, T4, R>) => lodash.Function0<R>;
    type LodashPartialRight27x1 = (args: readonly any[]) => (...args: any[]) => any;
    type LodashPartialRight27x2 = (func: (...args: any[]) => any) => (...args: any[]) => any;
    interface LodashPartition {
        <T, U extends T>(callback: lodash.ValueIteratorTypeGuard<T, U>): LodashPartition1x1<T, U>;
        <T>(callback: lodash.__, collection: lodash.List<T> | null | undefined): LodashPartition1x2<T>;
        <T, U extends T>(callback: lodash.ValueIteratorTypeGuard<T, U>, collection: lodash.List<T> | null | undefined): [U[], Array<Exclude<T, U>>];
        <T>(callback: lodash.ValueIteratee<T>): LodashPartition2x1<T>;
        <T>(callback: lodash.ValueIteratee<T>, collection: lodash.List<T> | null | undefined): [T[], T[]];
        <T extends object>(callback: lodash.__, collection: T | null | undefined): LodashPartition3x2<T>;
        <T extends object>(callback: lodash.ValueIteratee<T[keyof T]>, collection: T | null | undefined): [Array<T[keyof T]>, Array<T[keyof T]>];
    }
    type LodashPartition1x1<T, U> = (collection: lodash.List<T> | null | undefined) => [U[], Array<Exclude<T, U>>];
    interface LodashPartition1x2<T> {
        <U extends T>(callback: lodash.ValueIteratorTypeGuard<T, U>): [U[], Array<Exclude<T, U>>];
        (callback: lodash.ValueIteratee<T>): [T[], T[]];
    }
    type LodashPartition2x1<T> = (collection: lodash.List<T> | object | null | undefined) => [T[], T[]];
    type LodashPartition3x2<T> = (callback: lodash.ValueIteratee<T[keyof T]>) => [Array<T[keyof T]>, Array<T[keyof T]>];
    interface LodashPath {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashPath1x1<TObject, TKey>;
        <TObject extends object>(path: lodash.__, object: TObject): LodashPath1x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashPath2x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashPath3x1<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject): TObject[TKey1][TKey2];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashPath5x1<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject): TObject[TKey1][TKey2][TKey3];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashPath7x1<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
        (path: number): LodashPath9x1;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T>): LodashPath9x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T>): T;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPath10x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
        (path: lodash.PropertyPath): LodashPath11x1;
        (path: lodash.__, object: null | undefined): LodashPath11x2;
        (path: lodash.PropertyPath, object: null | undefined): undefined;
        (path: lodash.__, object: any): LodashPath12x2;
        (path: lodash.PropertyPath, object: any): any;
    }
    interface LodashPath1x1<TObject, TKey extends keyof TObject> {
        (object: TObject): TObject[TKey];
        (object: TObject | null | undefined): TObject[TKey] | undefined;
    }
    interface LodashPath1x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
    }
    interface LodashPath2x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashPath3x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        (object: TObject): TObject[TKey1][TKey2];
        (object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
    }
    interface LodashPath5x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
    }
    interface LodashPath7x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashPath9x1 {
        <T>(object: lodash.NumericDictionary<T>): T;
        <T>(object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
    }
    type LodashPath9x2<T> = (path: number) => T;
    type LodashPath10x2<T> = (path: number) => T | undefined;
    interface LodashPath11x1 {
        (object: null | undefined): undefined;
        (object: any): any;
    }
    type LodashPath11x2 = (path: lodash.PropertyPath) => undefined;
    type LodashPath12x2 = (path: lodash.PropertyPath) => any;
    interface LodashPathOr {
        <TDefault>(defaultValue: TDefault): LodashPathOr1x1<TDefault>;
        <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashPathOr1x2<TObject, TKey>;
        <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): LodashPathOr1x3<TObject, TKey, TDefault>;
        <TObject extends object>(defaultValue: lodash.__, path: lodash.__, object: TObject | null | undefined): LodashPathOr1x4<TObject>;
        <TObject extends object, TDefault>(defaultValue: TDefault, path: lodash.__, object: TObject | null | undefined): LodashPathOr1x5<TObject, TDefault>;
        <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey], object: TObject | null | undefined): LodashPathOr1x6<TObject, TKey>;
        <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey], object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2]): LodashPathOr2x2<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2]): LodashPathOr2x3<TObject, TKey1, TKey2, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2], object: TObject | null | undefined): LodashPathOr2x6<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3]): LodashPathOr3x2<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3]): LodashPathOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): LodashPathOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4]): LodashPathOr4x2<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4]): LodashPathOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): LodashPathOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
        (defaultValue: lodash.__, path: number): LodashPathOr5x2;
        <TDefault>(defaultValue: TDefault, path: number): LodashPathOr5x3<TDefault>;
        <T>(defaultValue: lodash.__, path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPathOr5x4<T>;
        <T, TDefault>(defaultValue: TDefault, path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPathOr5x5<T, TDefault>;
        <T>(defaultValue: lodash.__, path: number, object: lodash.NumericDictionary<T> | null | undefined): LodashPathOr5x6<T>;
        <T, TDefault>(defaultValue: TDefault, path: number, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPathOr6x2;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath): LodashPathOr6x3<TDefault>;
        (defaultValue: lodash.__, path: lodash.__, object: null | undefined): LodashPathOr6x4;
        <TDefault>(defaultValue: TDefault, path: lodash.__, object: null | undefined): LodashPathOr6x5<TDefault>;
        (defaultValue: lodash.__, path: lodash.PropertyPath, object: null | undefined): LodashPathOr6x6;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath, object: null | undefined): TDefault;
        (defaultValue: any): LodashPathOr7x1;
        (defaultValue: any, path: lodash.PropertyPath): LodashPathOr7x3;
        (defaultValue: lodash.__, path: lodash.__, object: any): LodashPathOr7x4;
        (defaultValue: any, path: lodash.__, object: any): LodashPathOr7x5;
        (defaultValue: lodash.__, path: lodash.PropertyPath, object: any): LodashPathOr7x6;
        (defaultValue: any, path: lodash.PropertyPath, object: any): any;
    }
    interface LodashPathOr1x1<TDefault> {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashPathOr1x3<TObject, TKey, TDefault>;
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashPathOr1x5<TObject, TDefault>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashPathOr2x3<TObject, TKey1, TKey2, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashPathOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashPathOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
        (path: number): LodashPathOr5x3<TDefault>;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPathOr5x5<T, TDefault>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
        (path: lodash.PropertyPath): LodashPathOr6x3<TDefault>;
        (path: lodash.__, object: null | undefined): LodashPathOr6x5<TDefault>;
        (path: lodash.PropertyPath, object: null | undefined): TDefault;
    }
    interface LodashPathOr1x2<TObject, TKey extends keyof TObject> {
        <TDefault>(defaultValue: TDefault): LodashPathOr1x3<TObject, TKey, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPathOr1x6<TObject, TKey>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
    }
    type LodashPathOr1x3<TObject, TKey extends keyof TObject, TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey], undefined> | TDefault;
    interface LodashPathOr1x4<TObject> {
        <TDefault>(defaultValue: TDefault): LodashPathOr1x5<TObject, TDefault>;
        <TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashPathOr1x6<TObject, TKey>;
        <TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): Exclude<TObject[TKey], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2]): LodashPathOr2x6<TObject, TKey1, TKey2>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2]): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3]): LodashPathOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3]): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4]): LodashPathOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4]): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    interface LodashPathOr1x5<TObject, TDefault> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): Exclude<TObject[TKey], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    type LodashPathOr1x6<TObject, TKey extends keyof TObject> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey], undefined> | TDefault;
    interface LodashPathOr2x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        <TDefault>(defaultValue: TDefault): LodashPathOr2x3<TObject, TKey1, TKey2, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPathOr2x6<TObject, TKey1, TKey2>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    }
    type LodashPathOr2x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    type LodashPathOr2x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    interface LodashPathOr3x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        <TDefault>(defaultValue: TDefault): LodashPathOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPathOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    }
    type LodashPathOr3x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    type LodashPathOr3x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    interface LodashPathOr4x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        <TDefault>(defaultValue: TDefault): LodashPathOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPathOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    type LodashPathOr4x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    type LodashPathOr4x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    interface LodashPathOr5x2 {
        <TDefault>(defaultValue: TDefault): LodashPathOr5x3<TDefault>;
        <T>(defaultValue: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPathOr5x6<T>;
        <T, TDefault>(defaultValue: TDefault, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
    }
    type LodashPathOr5x3<TDefault> = <T>(object: lodash.NumericDictionary<T> | null | undefined) => T | TDefault;
    interface LodashPathOr5x4<T> {
        <TDefault>(defaultValue: TDefault): LodashPathOr5x5<T, TDefault>;
        (defaultValue: lodash.__, path: number): LodashPathOr5x6<T>;
        <TDefault>(defaultValue: TDefault, path: number): T | TDefault;
    }
    type LodashPathOr5x5<T, TDefault> = (path: number) => T | TDefault;
    type LodashPathOr5x6<T> = <TDefault>(defaultValue: TDefault) => T | TDefault;
    interface LodashPathOr6x2 {
        <TDefault>(defaultValue: TDefault): LodashPathOr6x3<TDefault>;
        (defaultValue: lodash.__, object: null | undefined): LodashPathOr6x6;
        <TDefault>(defaultValue: TDefault, object: null | undefined): TDefault;
        (defaultValue: any): LodashPathOr7x3;
        (defaultValue: lodash.__, object: any): LodashPathOr7x6;
        (defaultValue: any, object: any): any;
    }
    type LodashPathOr6x3<TDefault> = (object: null | undefined) => TDefault;
    interface LodashPathOr6x4 {
        <TDefault>(defaultValue: TDefault): LodashPathOr6x5<TDefault>;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPathOr6x6;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath): TDefault;
    }
    type LodashPathOr6x5<TDefault> = (path: lodash.PropertyPath) => TDefault;
    type LodashPathOr6x6 = <TDefault>(defaultValue: TDefault) => TDefault;
    interface LodashPathOr7x1 {
        (path: lodash.PropertyPath): LodashPathOr7x3;
        (path: lodash.__, object: any): LodashPathOr7x5;
        (path: lodash.PropertyPath, object: any): any;
    }
    type LodashPathOr7x3 = (object: any) => any;
    interface LodashPathOr7x4 {
        (defaultValue: any): LodashPathOr7x5;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPathOr7x6;
        (defaultValue: any, path: lodash.PropertyPath): any;
    }
    type LodashPathOr7x5 = (path: lodash.PropertyPath) => any;
    type LodashPathOr7x6 = (defaultValue: any) => any;
    interface LodashPick {
        <T extends object, U extends keyof T>(props: lodash.Many<U>): LodashPick1x1<T, U>;
        <T extends object>(props: lodash.__, object: T): LodashPick1x2<T>;
        <T extends object, U extends keyof T>(props: lodash.Many<U>, object: T): Pick<T, U>;
        (props: lodash.PropertyPath): LodashPick2x1;
        <T>(props: lodash.__, object: T | null | undefined): LodashPick2x2<T>;
        <T>(props: lodash.PropertyPath, object: T | null | undefined): lodash.PartialObject<T>;
    }
    type LodashPick1x1<T, U extends keyof T> = (object: T) => Pick<T, U>;
    type LodashPick1x2<T> = <U extends keyof T>(props: lodash.Many<U>) => Pick<T, U>;
    type LodashPick2x1 = <T>(object: T | null | undefined) => lodash.PartialObject<T>;
    type LodashPick2x2<T> = (props: lodash.PropertyPath) => lodash.PartialObject<T>;
    interface LodashPickBy {
        <T, S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>): LodashPickBy1x1<T, S>;
        <T>(predicate: lodash.__, object: lodash.Dictionary<T> | null | undefined): LodashPickBy1x2<T>;
        <T, S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>, object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<S>;
        <T>(predicate: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPickBy2x2<T>;
        <T, S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>, object: lodash.NumericDictionary<T> | null | undefined): lodash.NumericDictionary<S>;
        <T>(predicate: lodash.ValueKeyIteratee<T>): LodashPickBy3x1<T>;
        <T>(predicate: lodash.ValueKeyIteratee<T>, object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<T>;
        <T>(predicate: lodash.ValueKeyIteratee<T>, object: lodash.NumericDictionary<T> | null | undefined): lodash.NumericDictionary<T>;
        <T extends object>(predicate: lodash.__, object: T | null | undefined): LodashPickBy5x2<T>;
        <T extends object>(predicate: lodash.ValueKeyIteratee<T[keyof T]>, object: T | null | undefined): lodash.PartialObject<T>;
    }
    interface LodashPickBy1x1<T, S> {
        (object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<S>;
        (object: lodash.NumericDictionary<T> | null | undefined): lodash.NumericDictionary<S>;
    }
    interface LodashPickBy1x2<T> {
        <S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>): lodash.Dictionary<S>;
        (predicate: lodash.ValueKeyIteratee<T>): lodash.Dictionary<T>;
    }
    interface LodashPickBy2x2<T> {
        <S extends T>(predicate: lodash.ValueKeyIterateeTypeGuard<T, S>): lodash.NumericDictionary<S>;
        (predicate: lodash.ValueKeyIteratee<T>): lodash.NumericDictionary<T>;
    }
    interface LodashPickBy3x1<T> {
        (object: lodash.Dictionary<T> | null | undefined): lodash.Dictionary<T>;
        (object: lodash.NumericDictionary<T> | null | undefined): lodash.NumericDictionary<T>;
        <T1 extends object>(object: T1 | null | undefined): lodash.PartialObject<T1>;
    }
    type LodashPickBy5x2<T> = (predicate: lodash.ValueKeyIteratee<T[keyof T]>) => lodash.PartialObject<T>;
    interface LodashProp {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashProp1x1<TObject, TKey>;
        <TObject extends object>(path: lodash.__, object: TObject): LodashProp1x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashProp2x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashProp3x1<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject): TObject[TKey1][TKey2];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashProp5x1<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject): TObject[TKey1][TKey2][TKey3];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashProp7x1<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
        (path: number): LodashProp9x1;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T>): LodashProp9x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T>): T;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashProp10x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
        (path: lodash.PropertyPath): LodashProp11x1;
        (path: lodash.__, object: null | undefined): LodashProp11x2;
        (path: lodash.PropertyPath, object: null | undefined): undefined;
        (path: lodash.__, object: any): LodashProp12x2;
        (path: lodash.PropertyPath, object: any): any;
    }
    interface LodashProp1x1<TObject, TKey extends keyof TObject> {
        (object: TObject): TObject[TKey];
        (object: TObject | null | undefined): TObject[TKey] | undefined;
    }
    interface LodashProp1x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
    }
    interface LodashProp2x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashProp3x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        (object: TObject): TObject[TKey1][TKey2];
        (object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
    }
    interface LodashProp5x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
    }
    interface LodashProp7x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashProp9x1 {
        <T>(object: lodash.NumericDictionary<T>): T;
        <T>(object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
    }
    type LodashProp9x2<T> = (path: number) => T;
    type LodashProp10x2<T> = (path: number) => T | undefined;
    interface LodashProp11x1 {
        (object: null | undefined): undefined;
        (object: any): any;
    }
    type LodashProp11x2 = (path: lodash.PropertyPath) => undefined;
    type LodashProp12x2 = (path: lodash.PropertyPath) => any;
    interface LodashProperty {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashProperty1x1<TObject, TKey>;
        <TObject extends object>(path: lodash.__, object: TObject): LodashProperty1x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashProperty2x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashProperty3x1<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject): TObject[TKey1][TKey2];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashProperty5x1<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject): TObject[TKey1][TKey2][TKey3];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashProperty7x1<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
        (path: number): LodashProperty9x1;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T>): LodashProperty9x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T>): T;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashProperty10x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
        (path: lodash.PropertyPath): LodashProperty11x1;
        (path: lodash.__, object: null | undefined): LodashProperty11x2;
        (path: lodash.PropertyPath, object: null | undefined): undefined;
        (path: lodash.__, object: any): LodashProperty12x2;
        (path: lodash.PropertyPath, object: any): any;
    }
    interface LodashProperty1x1<TObject, TKey extends keyof TObject> {
        (object: TObject): TObject[TKey];
        (object: TObject | null | undefined): TObject[TKey] | undefined;
    }
    interface LodashProperty1x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
    }
    interface LodashProperty2x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashProperty3x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        (object: TObject): TObject[TKey1][TKey2];
        (object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
    }
    interface LodashProperty5x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
    }
    interface LodashProperty7x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashProperty9x1 {
        <T>(object: lodash.NumericDictionary<T>): T;
        <T>(object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
    }
    type LodashProperty9x2<T> = (path: number) => T;
    type LodashProperty10x2<T> = (path: number) => T | undefined;
    interface LodashProperty11x1 {
        (object: null | undefined): undefined;
        (object: any): any;
    }
    type LodashProperty11x2 = (path: lodash.PropertyPath) => undefined;
    type LodashProperty12x2 = (path: lodash.PropertyPath) => any;
    interface LodashPropertyOf {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashPropertyOf1x1<TObject, TKey>;
        <TObject extends object>(path: lodash.__, object: TObject): LodashPropertyOf1x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject): TObject[TKey];
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashPropertyOf2x2<TObject>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): TObject[TKey] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashPropertyOf3x1<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject): TObject[TKey1][TKey2];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashPropertyOf5x1<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject): TObject[TKey1][TKey2][TKey3];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashPropertyOf7x1<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
        (path: number): LodashPropertyOf9x1;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T>): LodashPropertyOf9x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T>): T;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPropertyOf10x2<T>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
        (path: lodash.PropertyPath): LodashPropertyOf11x1;
        (path: lodash.__, object: null | undefined): LodashPropertyOf11x2;
        (path: lodash.PropertyPath, object: null | undefined): undefined;
        (path: lodash.__, object: any): LodashPropertyOf12x2;
        (path: lodash.PropertyPath, object: any): any;
    }
    interface LodashPropertyOf1x1<TObject, TKey extends keyof TObject> {
        (object: TObject): TObject[TKey];
        (object: TObject | null | undefined): TObject[TKey] | undefined;
    }
    interface LodashPropertyOf1x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3];
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4];
    }
    interface LodashPropertyOf2x2<TObject> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): TObject[TKey] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): TObject[TKey1][TKey2] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): TObject[TKey1][TKey2][TKey3] | undefined;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashPropertyOf3x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        (object: TObject): TObject[TKey1][TKey2];
        (object: TObject | null | undefined): TObject[TKey1][TKey2] | undefined;
    }
    interface LodashPropertyOf5x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3] | undefined;
    }
    interface LodashPropertyOf7x1<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        (object: TObject): TObject[TKey1][TKey2][TKey3][TKey4];
        (object: TObject | null | undefined): TObject[TKey1][TKey2][TKey3][TKey4] | undefined;
    }
    interface LodashPropertyOf9x1 {
        <T>(object: lodash.NumericDictionary<T>): T;
        <T>(object: lodash.NumericDictionary<T> | null | undefined): T | undefined;
    }
    type LodashPropertyOf9x2<T> = (path: number) => T;
    type LodashPropertyOf10x2<T> = (path: number) => T | undefined;
    interface LodashPropertyOf11x1 {
        (object: null | undefined): undefined;
        (object: any): any;
    }
    type LodashPropertyOf11x2 = (path: lodash.PropertyPath) => undefined;
    type LodashPropertyOf12x2 = (path: lodash.PropertyPath) => any;
    interface LodashPropOr {
        <TDefault>(defaultValue: TDefault): LodashPropOr1x1<TDefault>;
        <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashPropOr1x2<TObject, TKey>;
        <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): LodashPropOr1x3<TObject, TKey, TDefault>;
        <TObject extends object>(defaultValue: lodash.__, path: lodash.__, object: TObject | null | undefined): LodashPropOr1x4<TObject>;
        <TObject extends object, TDefault>(defaultValue: TDefault, path: lodash.__, object: TObject | null | undefined): LodashPropOr1x5<TObject, TDefault>;
        <TObject extends object, TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey], object: TObject | null | undefined): LodashPropOr1x6<TObject, TKey>;
        <TObject extends object, TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey], object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2]): LodashPropOr2x2<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2]): LodashPropOr2x3<TObject, TKey1, TKey2, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2], object: TObject | null | undefined): LodashPropOr2x6<TObject, TKey1, TKey2>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3]): LodashPropOr3x2<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3]): LodashPropOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): LodashPropOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4]): LodashPropOr4x2<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4]): LodashPropOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): LodashPropOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
        (defaultValue: lodash.__, path: number): LodashPropOr5x2;
        <TDefault>(defaultValue: TDefault, path: number): LodashPropOr5x3<TDefault>;
        <T>(defaultValue: lodash.__, path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPropOr5x4<T>;
        <T, TDefault>(defaultValue: TDefault, path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPropOr5x5<T, TDefault>;
        <T>(defaultValue: lodash.__, path: number, object: lodash.NumericDictionary<T> | null | undefined): LodashPropOr5x6<T>;
        <T, TDefault>(defaultValue: TDefault, path: number, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPropOr6x2;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath): LodashPropOr6x3<TDefault>;
        (defaultValue: lodash.__, path: lodash.__, object: null | undefined): LodashPropOr6x4;
        <TDefault>(defaultValue: TDefault, path: lodash.__, object: null | undefined): LodashPropOr6x5<TDefault>;
        (defaultValue: lodash.__, path: lodash.PropertyPath, object: null | undefined): LodashPropOr6x6;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath, object: null | undefined): TDefault;
        (defaultValue: any): LodashPropOr7x1;
        (defaultValue: any, path: lodash.PropertyPath): LodashPropOr7x3;
        (defaultValue: lodash.__, path: lodash.__, object: any): LodashPropOr7x4;
        (defaultValue: any, path: lodash.__, object: any): LodashPropOr7x5;
        (defaultValue: lodash.__, path: lodash.PropertyPath, object: any): LodashPropOr7x6;
        (defaultValue: any, path: lodash.PropertyPath, object: any): any;
    }
    interface LodashPropOr1x1<TDefault> {
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey]): LodashPropOr1x3<TObject, TKey, TDefault>;
        <TObject extends object>(path: lodash.__, object: TObject | null | undefined): LodashPropOr1x5<TObject, TDefault>;
        <TObject extends object, TKey extends keyof TObject>(path: TKey | [TKey], object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): LodashPropOr2x3<TObject, TKey1, TKey2, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): LodashPropOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): LodashPropOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        <TObject extends object, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4], object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
        (path: number): LodashPropOr5x3<TDefault>;
        <T>(path: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPropOr5x5<T, TDefault>;
        <T>(path: number, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
        (path: lodash.PropertyPath): LodashPropOr6x3<TDefault>;
        (path: lodash.__, object: null | undefined): LodashPropOr6x5<TDefault>;
        (path: lodash.PropertyPath, object: null | undefined): TDefault;
    }
    interface LodashPropOr1x2<TObject, TKey extends keyof TObject> {
        <TDefault>(defaultValue: TDefault): LodashPropOr1x3<TObject, TKey, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPropOr1x6<TObject, TKey>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey], undefined> | TDefault;
    }
    type LodashPropOr1x3<TObject, TKey extends keyof TObject, TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey], undefined> | TDefault;
    interface LodashPropOr1x4<TObject> {
        <TDefault>(defaultValue: TDefault): LodashPropOr1x5<TObject, TDefault>;
        <TKey extends keyof TObject>(defaultValue: lodash.__, path: TKey | [TKey]): LodashPropOr1x6<TObject, TKey>;
        <TKey extends keyof TObject, TDefault>(defaultValue: TDefault, path: TKey | [TKey]): Exclude<TObject[TKey], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(defaultValue: lodash.__, path: [TKey1, TKey2]): LodashPropOr2x6<TObject, TKey1, TKey2>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2]): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3]): LodashPropOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3]): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(defaultValue: lodash.__, path: [TKey1, TKey2, TKey3, TKey4]): LodashPropOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault>(defaultValue: TDefault, path: [TKey1, TKey2, TKey3, TKey4]): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    interface LodashPropOr1x5<TObject, TDefault> {
        <TKey extends keyof TObject>(path: TKey | [TKey]): Exclude<TObject[TKey], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]>(path: [TKey1, TKey2]): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]>(path: [TKey1, TKey2, TKey3]): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
        <TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]>(path: [TKey1, TKey2, TKey3, TKey4]): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    type LodashPropOr1x6<TObject, TKey extends keyof TObject> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey], undefined> | TDefault;
    interface LodashPropOr2x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> {
        <TDefault>(defaultValue: TDefault): LodashPropOr2x3<TObject, TKey1, TKey2, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPropOr2x6<TObject, TKey1, TKey2>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    }
    type LodashPropOr2x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    type LodashPropOr2x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2], undefined> | TDefault;
    interface LodashPropOr3x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> {
        <TDefault>(defaultValue: TDefault): LodashPropOr3x3<TObject, TKey1, TKey2, TKey3, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPropOr3x6<TObject, TKey1, TKey2, TKey3>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    }
    type LodashPropOr3x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    type LodashPropOr3x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2][TKey3], undefined> | TDefault;
    interface LodashPropOr4x2<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> {
        <TDefault>(defaultValue: TDefault): LodashPropOr4x3<TObject, TKey1, TKey2, TKey3, TKey4, TDefault>;
        (defaultValue: lodash.__, object: TObject | null | undefined): LodashPropOr4x6<TObject, TKey1, TKey2, TKey3, TKey4>;
        <TDefault>(defaultValue: TDefault, object: TObject | null | undefined): Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    }
    type LodashPropOr4x3<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3], TDefault> = (object: TObject | null | undefined) => Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    type LodashPropOr4x6<TObject, TKey1 extends keyof TObject, TKey2 extends keyof TObject[TKey1], TKey3 extends keyof TObject[TKey1][TKey2], TKey4 extends keyof TObject[TKey1][TKey2][TKey3]> = <TDefault>(defaultValue: TDefault) => Exclude<TObject[TKey1][TKey2][TKey3][TKey4], undefined> | TDefault;
    interface LodashPropOr5x2 {
        <TDefault>(defaultValue: TDefault): LodashPropOr5x3<TDefault>;
        <T>(defaultValue: lodash.__, object: lodash.NumericDictionary<T> | null | undefined): LodashPropOr5x6<T>;
        <T, TDefault>(defaultValue: TDefault, object: lodash.NumericDictionary<T> | null | undefined): T | TDefault;
    }
    type LodashPropOr5x3<TDefault> = <T>(object: lodash.NumericDictionary<T> | null | undefined) => T | TDefault;
    interface LodashPropOr5x4<T> {
        <TDefault>(defaultValue: TDefault): LodashPropOr5x5<T, TDefault>;
        (defaultValue: lodash.__, path: number): LodashPropOr5x6<T>;
        <TDefault>(defaultValue: TDefault, path: number): T | TDefault;
    }
    type LodashPropOr5x5<T, TDefault> = (path: number) => T | TDefault;
    type LodashPropOr5x6<T> = <TDefault>(defaultValue: TDefault) => T | TDefault;
    interface LodashPropOr6x2 {
        <TDefault>(defaultValue: TDefault): LodashPropOr6x3<TDefault>;
        (defaultValue: lodash.__, object: null | undefined): LodashPropOr6x6;
        <TDefault>(defaultValue: TDefault, object: null | undefined): TDefault;
        (defaultValue: any): LodashPropOr7x3;
        (defaultValue: lodash.__, object: any): LodashPropOr7x6;
        (defaultValue: any, object: any): any;
    }
    type LodashPropOr6x3<TDefault> = (object: null | undefined) => TDefault;
    interface LodashPropOr6x4 {
        <TDefault>(defaultValue: TDefault): LodashPropOr6x5<TDefault>;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPropOr6x6;
        <TDefault>(defaultValue: TDefault, path: lodash.PropertyPath): TDefault;
    }
    type LodashPropOr6x5<TDefault> = (path: lodash.PropertyPath) => TDefault;
    type LodashPropOr6x6 = <TDefault>(defaultValue: TDefault) => TDefault;
    interface LodashPropOr7x1 {
        (path: lodash.PropertyPath): LodashPropOr7x3;
        (path: lodash.__, object: any): LodashPropOr7x5;
        (path: lodash.PropertyPath, object: any): any;
    }
    type LodashPropOr7x3 = (object: any) => any;
    interface LodashPropOr7x4 {
        (defaultValue: any): LodashPropOr7x5;
        (defaultValue: lodash.__, path: lodash.PropertyPath): LodashPropOr7x6;
        (defaultValue: any, path: lodash.PropertyPath): any;
    }
    type LodashPropOr7x5 = (path: lodash.PropertyPath) => any;
    type LodashPropOr7x6 = (defaultValue: any) => any;
    interface LodashPull {
        <T>(values: T): LodashPull1x1<T>;
        <T>(values: lodash.__, array: readonly T[]): LodashPull1x2<T>;
        <T>(values: T, array: readonly T[]): T[];
        <T>(values: lodash.__, array: lodash.List<T>): LodashPull2x2<T>;
        <T>(values: T, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPull1x1<T> {
        (array: readonly T[]): T[];
        (array: lodash.List<T>): lodash.List<T>;
    }
    type LodashPull1x2<T> = (values: T) => T[];
    type LodashPull2x2<T> = (values: T) => lodash.List<T>;
    interface LodashPullAll {
        <T>(values: lodash.List<T>): LodashPullAll1x1<T>;
        <T>(values: lodash.__, array: readonly T[]): LodashPullAll1x2<T>;
        <T>(values: lodash.List<T>, array: readonly T[]): T[];
        <T>(values: lodash.__, array: lodash.List<T>): LodashPullAll2x2<T>;
        <T>(values: lodash.List<T>, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAll1x1<T> {
        (array: readonly T[]): T[];
        (array: lodash.List<T>): lodash.List<T>;
    }
    type LodashPullAll1x2<T> = (values: lodash.List<T>) => T[];
    type LodashPullAll2x2<T> = (values: lodash.List<T>) => lodash.List<T>;
    interface LodashPullAllBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashPullAllBy1x1<T>;
        <T>(iteratee: lodash.__, values: lodash.List<T>): LodashPullAllBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, values: lodash.List<T>): LodashPullAllBy1x3<T>;
        <T>(iteratee: lodash.__, values: lodash.__, array: readonly T[]): LodashPullAllBy1x4<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, values: lodash.__, array: readonly T[]): LodashPullAllBy1x5<T>;
        <T>(iteratee: lodash.__, values: lodash.List<T>, array: readonly T[]): LodashPullAllBy1x6<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, values: lodash.List<T>, array: readonly T[]): T[];
        <T>(iteratee: lodash.__, values: lodash.__, array: lodash.List<T>): LodashPullAllBy2x4<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, values: lodash.__, array: lodash.List<T>): LodashPullAllBy2x5<T>;
        <T>(iteratee: lodash.__, values: lodash.List<T>, array: lodash.List<T>): LodashPullAllBy2x6<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, values: lodash.List<T>, array: lodash.List<T>): lodash.List<T>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashPullAllBy3x1<T1, T2>;
        <T2>(iteratee: lodash.__, values: lodash.List<T2>): LodashPullAllBy3x2<T2>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.List<T2>): LodashPullAllBy3x3<T1>;
        <T1>(iteratee: lodash.__, values: lodash.__, array: readonly T1[]): LodashPullAllBy3x4<T1>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.__, array: readonly T1[]): LodashPullAllBy3x5<T1, T2>;
        <T1, T2>(iteratee: lodash.__, values: lodash.List<T2>, array: readonly T1[]): LodashPullAllBy3x6<T1, T2>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.List<T2>, array: readonly T1[]): T1[];
        <T1>(iteratee: lodash.__, values: lodash.__, array: lodash.List<T1>): LodashPullAllBy4x4<T1>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.__, array: lodash.List<T1>): LodashPullAllBy4x5<T1, T2>;
        <T1, T2>(iteratee: lodash.__, values: lodash.List<T2>, array: lodash.List<T1>): LodashPullAllBy4x6<T1, T2>;
        <T1, T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.List<T2>, array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllBy1x1<T> {
        (values: lodash.List<T>): LodashPullAllBy1x3<T>;
        (values: lodash.__, array: readonly T[]): LodashPullAllBy1x5<T>;
        (values: lodash.List<T>, array: readonly T[]): T[];
        (values: lodash.__, array: lodash.List<T>): LodashPullAllBy2x5<T>;
        (values: lodash.List<T>, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAllBy1x2<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashPullAllBy1x3<T>;
        (iteratee: lodash.__, array: readonly T[]): LodashPullAllBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, array: readonly T[]): T[];
        (iteratee: lodash.__, array: lodash.List<T>): LodashPullAllBy2x6<T>;
        (iteratee: lodash.ValueIteratee<T>, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAllBy1x3<T> {
        (array: readonly T[]): T[];
        (array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAllBy1x4<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashPullAllBy1x5<T>;
        (iteratee: lodash.__, values: lodash.List<T>): LodashPullAllBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, values: lodash.List<T>): T[];
    }
    type LodashPullAllBy1x5<T> = (values: lodash.List<T>) => T[];
    type LodashPullAllBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
    interface LodashPullAllBy2x4<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashPullAllBy2x5<T>;
        (iteratee: lodash.__, values: lodash.List<T>): LodashPullAllBy2x6<T>;
        (iteratee: lodash.ValueIteratee<T>, values: lodash.List<T>): lodash.List<T>;
    }
    type LodashPullAllBy2x5<T> = (values: lodash.List<T>) => lodash.List<T>;
    type LodashPullAllBy2x6<T> = (iteratee: lodash.ValueIteratee<T>) => lodash.List<T>;
    interface LodashPullAllBy3x1<T1, T2> {
        (values: lodash.List<T2>): LodashPullAllBy3x3<T1>;
        (values: lodash.__, array: readonly T1[]): LodashPullAllBy3x5<T1, T2>;
        (values: lodash.List<T2>, array: readonly T1[]): T1[];
        (values: lodash.__, array: lodash.List<T1>): LodashPullAllBy4x5<T1, T2>;
        (values: lodash.List<T2>, array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllBy3x2<T2> {
        <T1>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashPullAllBy3x3<T1>;
        <T1>(iteratee: lodash.__, array: readonly T1[]): LodashPullAllBy3x6<T1, T2>;
        <T1>(iteratee: lodash.ValueIteratee<T1 | T2>, array: readonly T1[]): T1[];
        <T1>(iteratee: lodash.__, array: lodash.List<T1>): LodashPullAllBy4x6<T1, T2>;
        <T1>(iteratee: lodash.ValueIteratee<T1 | T2>, array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllBy3x3<T1> {
        (array: readonly T1[]): T1[];
        (array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllBy3x4<T1> {
        <T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashPullAllBy3x5<T1, T2>;
        <T2>(iteratee: lodash.__, values: lodash.List<T2>): LodashPullAllBy3x6<T1, T2>;
        <T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.List<T2>): T1[];
    }
    type LodashPullAllBy3x5<T1, T2> = (values: lodash.List<T2>) => T1[];
    type LodashPullAllBy3x6<T1, T2> = (iteratee: lodash.ValueIteratee<T1 | T2>) => T1[];
    interface LodashPullAllBy4x4<T1> {
        <T2>(iteratee: lodash.ValueIteratee<T1 | T2>): LodashPullAllBy4x5<T1, T2>;
        <T2>(iteratee: lodash.__, values: lodash.List<T2>): LodashPullAllBy4x6<T1, T2>;
        <T2>(iteratee: lodash.ValueIteratee<T1 | T2>, values: lodash.List<T2>): lodash.List<T1>;
    }
    type LodashPullAllBy4x5<T1, T2> = (values: lodash.List<T2>) => lodash.List<T1>;
    type LodashPullAllBy4x6<T1, T2> = (iteratee: lodash.ValueIteratee<T1 | T2>) => lodash.List<T1>;
    interface LodashPullAllWith {
        <T>(comparator: lodash.Comparator<T>): LodashPullAllWith1x1<T>;
        <T>(comparator: lodash.__, values: lodash.List<T>): LodashPullAllWith1x2<T>;
        <T>(comparator: lodash.Comparator<T>, values: lodash.List<T>): LodashPullAllWith1x3<T>;
        <T>(comparator: lodash.__, values: lodash.__, array: readonly T[]): LodashPullAllWith1x4<T>;
        <T>(comparator: lodash.Comparator<T>, values: lodash.__, array: readonly T[]): LodashPullAllWith1x5<T>;
        <T>(comparator: lodash.__, values: lodash.List<T>, array: readonly T[]): LodashPullAllWith1x6<T>;
        <T>(comparator: lodash.Comparator<T>, values: lodash.List<T>, array: readonly T[]): T[];
        <T>(comparator: lodash.__, values: lodash.__, array: lodash.List<T>): LodashPullAllWith2x4<T>;
        <T>(comparator: lodash.Comparator<T>, values: lodash.__, array: lodash.List<T>): LodashPullAllWith2x5<T>;
        <T>(comparator: lodash.__, values: lodash.List<T>, array: lodash.List<T>): LodashPullAllWith2x6<T>;
        <T>(comparator: lodash.Comparator<T>, values: lodash.List<T>, array: lodash.List<T>): lodash.List<T>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>): LodashPullAllWith3x1<T1, T2>;
        <T2>(comparator: lodash.__, values: lodash.List<T2>): LodashPullAllWith3x2<T2>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.List<T2>): LodashPullAllWith3x3<T1>;
        <T1>(comparator: lodash.__, values: lodash.__, array: readonly T1[]): LodashPullAllWith3x4<T1>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.__, array: readonly T1[]): LodashPullAllWith3x5<T1, T2>;
        <T1, T2>(comparator: lodash.__, values: lodash.List<T2>, array: readonly T1[]): LodashPullAllWith3x6<T1, T2>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.List<T2>, array: readonly T1[]): T1[];
        <T1>(comparator: lodash.__, values: lodash.__, array: lodash.List<T1>): LodashPullAllWith4x4<T1>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.__, array: lodash.List<T1>): LodashPullAllWith4x5<T1, T2>;
        <T1, T2>(comparator: lodash.__, values: lodash.List<T2>, array: lodash.List<T1>): LodashPullAllWith4x6<T1, T2>;
        <T1, T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.List<T2>, array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllWith1x1<T> {
        (values: lodash.List<T>): LodashPullAllWith1x3<T>;
        (values: lodash.__, array: readonly T[]): LodashPullAllWith1x5<T>;
        (values: lodash.List<T>, array: readonly T[]): T[];
        (values: lodash.__, array: lodash.List<T>): LodashPullAllWith2x5<T>;
        (values: lodash.List<T>, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAllWith1x2<T> {
        (comparator: lodash.Comparator<T>): LodashPullAllWith1x3<T>;
        (comparator: lodash.__, array: readonly T[]): LodashPullAllWith1x6<T>;
        (comparator: lodash.Comparator<T>, array: readonly T[]): T[];
        (comparator: lodash.__, array: lodash.List<T>): LodashPullAllWith2x6<T>;
        (comparator: lodash.Comparator<T>, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAllWith1x3<T> {
        (array: readonly T[]): T[];
        (array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAllWith1x4<T> {
        (comparator: lodash.Comparator<T>): LodashPullAllWith1x5<T>;
        (comparator: lodash.__, values: lodash.List<T>): LodashPullAllWith1x6<T>;
        (comparator: lodash.Comparator<T>, values: lodash.List<T>): T[];
    }
    type LodashPullAllWith1x5<T> = (values: lodash.List<T>) => T[];
    type LodashPullAllWith1x6<T> = (comparator: lodash.Comparator<T>) => T[];
    interface LodashPullAllWith2x4<T> {
        (comparator: lodash.Comparator<T>): LodashPullAllWith2x5<T>;
        (comparator: lodash.__, values: lodash.List<T>): LodashPullAllWith2x6<T>;
        (comparator: lodash.Comparator<T>, values: lodash.List<T>): lodash.List<T>;
    }
    type LodashPullAllWith2x5<T> = (values: lodash.List<T>) => lodash.List<T>;
    type LodashPullAllWith2x6<T> = (comparator: lodash.Comparator<T>) => lodash.List<T>;
    interface LodashPullAllWith3x1<T1, T2> {
        (values: lodash.List<T2>): LodashPullAllWith3x3<T1>;
        (values: lodash.__, array: readonly T1[]): LodashPullAllWith3x5<T1, T2>;
        (values: lodash.List<T2>, array: readonly T1[]): T1[];
        (values: lodash.__, array: lodash.List<T1>): LodashPullAllWith4x5<T1, T2>;
        (values: lodash.List<T2>, array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllWith3x2<T2> {
        <T1>(comparator: lodash.Comparator2<T1, T2>): LodashPullAllWith3x3<T1>;
        <T1>(comparator: lodash.__, array: readonly T1[]): LodashPullAllWith3x6<T1, T2>;
        <T1>(comparator: lodash.Comparator2<T1, T2>, array: readonly T1[]): T1[];
        <T1>(comparator: lodash.__, array: lodash.List<T1>): LodashPullAllWith4x6<T1, T2>;
        <T1>(comparator: lodash.Comparator2<T1, T2>, array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllWith3x3<T1> {
        (array: readonly T1[]): T1[];
        (array: lodash.List<T1>): lodash.List<T1>;
    }
    interface LodashPullAllWith3x4<T1> {
        <T2>(comparator: lodash.Comparator2<T1, T2>): LodashPullAllWith3x5<T1, T2>;
        <T2>(comparator: lodash.__, values: lodash.List<T2>): LodashPullAllWith3x6<T1, T2>;
        <T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.List<T2>): T1[];
    }
    type LodashPullAllWith3x5<T1, T2> = (values: lodash.List<T2>) => T1[];
    type LodashPullAllWith3x6<T1, T2> = (comparator: lodash.Comparator2<T1, T2>) => T1[];
    interface LodashPullAllWith4x4<T1> {
        <T2>(comparator: lodash.Comparator2<T1, T2>): LodashPullAllWith4x5<T1, T2>;
        <T2>(comparator: lodash.__, values: lodash.List<T2>): LodashPullAllWith4x6<T1, T2>;
        <T2>(comparator: lodash.Comparator2<T1, T2>, values: lodash.List<T2>): lodash.List<T1>;
    }
    type LodashPullAllWith4x5<T1, T2> = (values: lodash.List<T2>) => lodash.List<T1>;
    type LodashPullAllWith4x6<T1, T2> = (comparator: lodash.Comparator2<T1, T2>) => lodash.List<T1>;
    interface LodashPullAt {
        (indexes: lodash.Many<number>): LodashPullAt1x1;
        <T>(indexes: lodash.__, array: readonly T[]): LodashPullAt1x2<T>;
        <T>(indexes: lodash.Many<number>, array: readonly T[]): T[];
        <T>(indexes: lodash.__, array: lodash.List<T>): LodashPullAt2x2<T>;
        <T>(indexes: lodash.Many<number>, array: lodash.List<T>): lodash.List<T>;
    }
    interface LodashPullAt1x1 {
        <T>(array: readonly T[]): T[];
        <T>(array: lodash.List<T>): lodash.List<T>;
    }
    type LodashPullAt1x2<T> = (indexes: lodash.Many<number>) => T[];
    type LodashPullAt2x2<T> = (indexes: lodash.Many<number>) => lodash.List<T>;
    interface LodashRandom {
        (maxOrMin: number): LodashRandom1x1;
        (max: lodash.__, floating: boolean): LodashRandom1x2;
        (maxOrMin: number, floatingOrMax: boolean | number): number;
        (min: lodash.__, max: number): LodashRandom2x2;
    }
    type LodashRandom1x1 = (floatingOrMax: boolean | number) => number;
    type LodashRandom1x2 = (max: number) => number;
    type LodashRandom2x2 = (min: number) => number;
    interface LodashRange {
        (start: number): LodashRange1x1;
        (start: lodash.__, end: number): LodashRange1x2;
        (start: number, end: number): number[];
    }
    type LodashRange1x1 = (end: number) => number[];
    type LodashRange1x2 = (start: number) => number[];
    interface LodashRangeRight {
        (start: number): LodashRangeRight1x1;
        (start: lodash.__, end: number): LodashRangeRight1x2;
        (start: number, end: number): number[];
    }
    type LodashRangeRight1x1 = (end: number) => number[];
    type LodashRangeRight1x2 = (start: number) => number[];
    interface LodashRangeStep {
        (start: number): LodashRangeStep1x1;
        (start: lodash.__, end: number): LodashRangeStep1x2;
        (start: number, end: number): LodashRangeStep1x3;
        (start: lodash.__, end: lodash.__, step: number): LodashRangeStep1x4;
        (start: number, end: lodash.__, step: number): LodashRangeStep1x5;
        (start: lodash.__, end: number, step: number): LodashRangeStep1x6;
        (start: number, end: number, step: number): number[];
    }
    interface LodashRangeStep1x1 {
        (end: number): LodashRangeStep1x3;
        (end: lodash.__, step: number): LodashRangeStep1x5;
        (end: number, step: number): number[];
    }
    interface LodashRangeStep1x2 {
        (start: number): LodashRangeStep1x3;
        (start: lodash.__, step: number): LodashRangeStep1x6;
        (start: number, step: number): number[];
    }
    type LodashRangeStep1x3 = (step: number) => number[];
    interface LodashRangeStep1x4 {
        (start: number): LodashRangeStep1x5;
        (start: lodash.__, end: number): LodashRangeStep1x6;
        (start: number, end: number): number[];
    }
    type LodashRangeStep1x5 = (end: number) => number[];
    type LodashRangeStep1x6 = (start: number) => number[];
    interface LodashRangeStepRight {
        (start: number): LodashRangeStepRight1x1;
        (start: lodash.__, end: number): LodashRangeStepRight1x2;
        (start: number, end: number): LodashRangeStepRight1x3;
        (start: lodash.__, end: lodash.__, step: number): LodashRangeStepRight1x4;
        (start: number, end: lodash.__, step: number): LodashRangeStepRight1x5;
        (start: lodash.__, end: number, step: number): LodashRangeStepRight1x6;
        (start: number, end: number, step: number): number[];
    }
    interface LodashRangeStepRight1x1 {
        (end: number): LodashRangeStepRight1x3;
        (end: lodash.__, step: number): LodashRangeStepRight1x5;
        (end: number, step: number): number[];
    }
    interface LodashRangeStepRight1x2 {
        (start: number): LodashRangeStepRight1x3;
        (start: lodash.__, step: number): LodashRangeStepRight1x6;
        (start: number, step: number): number[];
    }
    type LodashRangeStepRight1x3 = (step: number) => number[];
    interface LodashRangeStepRight1x4 {
        (start: number): LodashRangeStepRight1x5;
        (start: lodash.__, end: number): LodashRangeStepRight1x6;
        (start: number, end: number): number[];
    }
    type LodashRangeStepRight1x5 = (end: number) => number[];
    type LodashRangeStepRight1x6 = (start: number) => number[];
    interface LodashRearg {
        (indexes: lodash.Many<number>): LodashRearg1x1;
        (indexes: lodash.__, func: (...args: any[]) => any): LodashRearg1x2;
        (indexes: lodash.Many<number>, func: (...args: any[]) => any): (...args: any[]) => any;
    }
    type LodashRearg1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any;
    type LodashRearg1x2 = (indexes: lodash.Many<number>) => (...args: any[]) => any;
    interface LodashReduce {
        <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>): LodashReduce1x1<T, TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduce1x2<TResult>;
        <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: TResult): LodashReduce1x3<T, TResult>;
        <T>(callback: lodash.__, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduce1x4<T>;
        <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduce1x5<TResult>;
        <T, TResult>(callback: lodash.__, accumulator: TResult, collection: T[] | null | undefined): LodashReduce1x6<T, TResult>;
        <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: TResult, collection: T[] | lodash.List<T> | null | undefined): TResult;
        <T>(callback: lodash.__, accumulator: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduce2x4<T>;
        <T, TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduce2x5<TResult>;
        <T, TResult>(callback: lodash.__, accumulator: TResult, collection: lodash.List<T> | null | undefined): LodashReduce2x6<T, TResult>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>): LodashReduce3x1<T, TResult>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>, accumulator: TResult): LodashReduce3x3<T, TResult>;
        <T extends object>(callback: lodash.__, accumulator: lodash.__, collection: T | null | undefined): LodashReduce3x4<T>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>, accumulator: lodash.__, collection: T | null | undefined): LodashReduce3x5<TResult>;
        <T extends object, TResult>(callback: lodash.__, accumulator: TResult, collection: T | null | undefined): LodashReduce3x6<T, TResult>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>, accumulator: TResult, collection: T | null | undefined): TResult;
    }
    interface LodashReduce1x1<T, TResult> {
        (accumulator: TResult): LodashReduce1x3<T, TResult>;
        (accumulator: lodash.__, collection: T[] | null | undefined): LodashReduce1x5<TResult>;
        (accumulator: TResult, collection: T[] | lodash.List<T> | null | undefined): TResult;
        (accumulator: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduce2x5<TResult>;
    }
    interface LodashReduce1x2<TResult> {
        <T>(callback: lodash.MemoIteratorCapped<T, TResult>): LodashReduce1x3<T, TResult>;
        <T>(callback: lodash.__, collection: T[] | null | undefined): LodashReduce1x6<T, TResult>;
        <T>(callback: lodash.MemoIteratorCapped<T, TResult>, collection: T[] | lodash.List<T> | null | undefined): TResult;
        <T>(callback: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduce2x6<T, TResult>;
        <T extends object>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>): LodashReduce3x3<T, TResult>;
        <T extends object>(callback: lodash.__, collection: T | null | undefined): LodashReduce3x6<T, TResult>;
        <T extends object>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>, collection: T | null | undefined): TResult;
    }
    type LodashReduce1x3<T, TResult> = (collection: T[] | lodash.List<T> | null | undefined) => TResult;
    interface LodashReduce1x4<T> {
        <TResult>(callback: lodash.MemoIteratorCapped<T, TResult>): LodashReduce1x5<TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduce1x6<T, TResult>;
        <TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: TResult): TResult;
    }
    type LodashReduce1x5<TResult> = (accumulator: TResult) => TResult;
    type LodashReduce1x6<T, TResult> = (callback: lodash.MemoIteratorCapped<T, TResult>) => TResult;
    interface LodashReduce2x4<T> {
        <TResult>(callback: lodash.MemoIteratorCapped<T, TResult>): LodashReduce2x5<TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduce2x6<T, TResult>;
        <TResult>(callback: lodash.MemoIteratorCapped<T, TResult>, accumulator: TResult): TResult;
    }
    type LodashReduce2x5<TResult> = (accumulator: TResult) => TResult;
    type LodashReduce2x6<T, TResult> = (callback: lodash.MemoIteratorCapped<T, TResult>) => TResult;
    interface LodashReduce3x1<T, TResult> {
        (accumulator: TResult): LodashReduce3x3<T, TResult>;
        (accumulator: lodash.__, collection: T | null | undefined): LodashReduce3x5<TResult>;
        (accumulator: TResult, collection: T | null | undefined): TResult;
    }
    type LodashReduce3x3<T, TResult> = (collection: T | null | undefined) => TResult;
    interface LodashReduce3x4<T> {
        <TResult>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>): LodashReduce3x5<TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduce3x6<T, TResult>;
        <TResult>(callback: lodash.MemoIteratorCapped<T[keyof T], TResult>, accumulator: TResult): TResult;
    }
    type LodashReduce3x5<TResult> = (accumulator: TResult) => TResult;
    type LodashReduce3x6<T, TResult> = (callback: lodash.MemoIteratorCapped<T[keyof T], TResult>) => TResult;
    interface LodashReduceRight {
        <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>): LodashReduceRight1x1<T, TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduceRight1x2<TResult>;
        <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: TResult): LodashReduceRight1x3<T, TResult>;
        <T>(callback: lodash.__, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x4<T>;
        <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x5<TResult>;
        <T, TResult>(callback: lodash.__, accumulator: TResult, collection: T[] | null | undefined): LodashReduceRight1x6<T, TResult>;
        <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: TResult, collection: T[] | lodash.List<T> | null | undefined): TResult;
        <T>(callback: lodash.__, accumulator: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduceRight2x4<T>;
        <T, TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduceRight2x5<TResult>;
        <T, TResult>(callback: lodash.__, accumulator: TResult, collection: lodash.List<T> | null | undefined): LodashReduceRight2x6<T, TResult>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>): LodashReduceRight3x1<T, TResult>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>, accumulator: TResult): LodashReduceRight3x3<T, TResult>;
        <T extends object>(callback: lodash.__, accumulator: lodash.__, collection: T | null | undefined): LodashReduceRight3x4<T>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>, accumulator: lodash.__, collection: T | null | undefined): LodashReduceRight3x5<TResult>;
        <T extends object, TResult>(callback: lodash.__, accumulator: TResult, collection: T | null | undefined): LodashReduceRight3x6<T, TResult>;
        <T extends object, TResult>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>, accumulator: TResult, collection: T | null | undefined): TResult;
    }
    interface LodashReduceRight1x1<T, TResult> {
        (accumulator: TResult): LodashReduceRight1x3<T, TResult>;
        (accumulator: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x5<TResult>;
        (accumulator: TResult, collection: T[] | lodash.List<T> | null | undefined): TResult;
        (accumulator: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduceRight2x5<TResult>;
    }
    interface LodashReduceRight1x2<TResult> {
        <T>(callback: lodash.MemoIteratorCappedRight<T, TResult>): LodashReduceRight1x3<T, TResult>;
        <T>(callback: lodash.__, collection: T[] | null | undefined): LodashReduceRight1x6<T, TResult>;
        <T>(callback: lodash.MemoIteratorCappedRight<T, TResult>, collection: T[] | lodash.List<T> | null | undefined): TResult;
        <T>(callback: lodash.__, collection: lodash.List<T> | null | undefined): LodashReduceRight2x6<T, TResult>;
        <T extends object>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>): LodashReduceRight3x3<T, TResult>;
        <T extends object>(callback: lodash.__, collection: T | null | undefined): LodashReduceRight3x6<T, TResult>;
        <T extends object>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>, collection: T | null | undefined): TResult;
    }
    type LodashReduceRight1x3<T, TResult> = (collection: T[] | lodash.List<T> | null | undefined) => TResult;
    interface LodashReduceRight1x4<T> {
        <TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>): LodashReduceRight1x5<TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduceRight1x6<T, TResult>;
        <TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: TResult): TResult;
    }
    type LodashReduceRight1x5<TResult> = (accumulator: TResult) => TResult;
    type LodashReduceRight1x6<T, TResult> = (callback: lodash.MemoIteratorCappedRight<T, TResult>) => TResult;
    interface LodashReduceRight2x4<T> {
        <TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>): LodashReduceRight2x5<TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduceRight2x6<T, TResult>;
        <TResult>(callback: lodash.MemoIteratorCappedRight<T, TResult>, accumulator: TResult): TResult;
    }
    type LodashReduceRight2x5<TResult> = (accumulator: TResult) => TResult;
    type LodashReduceRight2x6<T, TResult> = (callback: lodash.MemoIteratorCappedRight<T, TResult>) => TResult;
    interface LodashReduceRight3x1<T, TResult> {
        (accumulator: TResult): LodashReduceRight3x3<T, TResult>;
        (accumulator: lodash.__, collection: T | null | undefined): LodashReduceRight3x5<TResult>;
        (accumulator: TResult, collection: T | null | undefined): TResult;
    }
    type LodashReduceRight3x3<T, TResult> = (collection: T | null | undefined) => TResult;
    interface LodashReduceRight3x4<T> {
        <TResult>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>): LodashReduceRight3x5<TResult>;
        <TResult>(callback: lodash.__, accumulator: TResult): LodashReduceRight3x6<T, TResult>;
        <TResult>(callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>, accumulator: TResult): TResult;
    }
    type LodashReduceRight3x5<TResult> = (accumulator: TResult) => TResult;
    type LodashReduceRight3x6<T, TResult> = (callback: lodash.MemoIteratorCappedRight<T[keyof T], TResult>) => TResult;
    interface LodashReject {
        <T>(predicate: lodash.ValueIterateeCustom<T, boolean>): LodashReject1x1<T>;
        <T>(predicate: lodash.__, collection: lodash.List<T> | null | undefined): LodashReject1x2<T>;
        <T>(predicate: lodash.ValueIterateeCustom<T, boolean>, collection: lodash.List<T> | null | undefined): T[];
        <T extends object>(predicate: lodash.__, collection: T | null | undefined): LodashReject2x2<T>;
        <T extends object>(predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>, collection: T | null | undefined): Array<T[keyof T]>;
    }
    type LodashReject1x1<T> = (collection: lodash.List<T> | object | null | undefined) => T[];
    type LodashReject1x2<T> = (predicate: lodash.ValueIterateeCustom<T, boolean>) => T[];
    type LodashReject2x2<T> = (predicate: lodash.ValueIterateeCustom<T[keyof T], boolean>) => Array<T[keyof T]>;
    interface LodashRemove {
        <T>(predicate: lodash.ValueIteratee<T>): LodashRemove1x1<T>;
        <T>(predicate: lodash.__, array: lodash.List<T>): LodashRemove1x2<T>;
        <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T>): T[];
    }
    type LodashRemove1x1<T> = (array: lodash.List<T>) => T[];
    type LodashRemove1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
    interface LodashRepeat {
        (n: number): LodashRepeat1x1;
        (n: lodash.__, string: string): LodashRepeat1x2;
        (n: number, string: string): string;
    }
    type LodashRepeat1x1 = (string: string) => string;
    type LodashRepeat1x2 = (n: number) => string;
    interface LodashReplace {
        (pattern: RegExp | string): LodashReplace1x1;
        (pattern: lodash.__, replacement: lodash.ReplaceFunction | string): LodashReplace1x2;
        (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string): LodashReplace1x3;
        (pattern: lodash.__, replacement: lodash.__, string: string): LodashReplace1x4;
        (pattern: RegExp | string, replacement: lodash.__, string: string): LodashReplace1x5;
        (pattern: lodash.__, replacement: lodash.ReplaceFunction | string, string: string): LodashReplace1x6;
        (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string, string: string): string;
    }
    interface LodashReplace1x1 {
        (replacement: lodash.ReplaceFunction | string): LodashReplace1x3;
        (replacement: lodash.__, string: string): LodashReplace1x5;
        (replacement: lodash.ReplaceFunction | string, string: string): string;
    }
    interface LodashReplace1x2 {
        (pattern: RegExp | string): LodashReplace1x3;
        (pattern: lodash.__, string: string): LodashReplace1x6;
        (pattern: RegExp | string, string: string): string;
    }
    type LodashReplace1x3 = (string: string) => string;
    interface LodashReplace1x4 {
        (pattern: RegExp | string): LodashReplace1x5;
        (pattern: lodash.__, replacement: lodash.ReplaceFunction | string): LodashReplace1x6;
        (pattern: RegExp | string, replacement: lodash.ReplaceFunction | string): string;
    }
    type LodashReplace1x5 = (replacement: lodash.ReplaceFunction | string) => string;
    type LodashReplace1x6 = (pattern: RegExp | string) => string;
    type LodashRest = (func: (...args: any[]) => any) => (...args: any[]) => any;
    interface LodashRestFrom {
        (start: number): LodashRestFrom1x1;
        (start: lodash.__, func: (...args: any[]) => any): LodashRestFrom1x2;
        (start: number, func: (...args: any[]) => any): (...args: any[]) => any;
    }
    type LodashRestFrom1x1 = (func: (...args: any[]) => any) => (...args: any[]) => any;
    type LodashRestFrom1x2 = (start: number) => (...args: any[]) => any;
    interface LodashResult {
        (path: lodash.PropertyPath): LodashResult1x1;
        (path: lodash.__, object: any): LodashResult1x2;
        <TResult>(path: lodash.PropertyPath, object: any): TResult;
    }
    type LodashResult1x1 = <TResult>(object: any) => TResult;
    type LodashResult1x2 = <TResult>(path: lodash.PropertyPath) => TResult;
    type LodashReverse = <TList extends lodash.List<any>>(array: TList) => TList;
    type LodashRound = (n: number) => number;
    type LodashRunInContext = (context: object) => lodash.LoDashStatic;
    interface LodashSample {
        <T>(collection: readonly [T, ...T[]]): T;
        <T>(collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T | undefined;
        <T extends object>(collection: T | null | undefined): T[keyof T] | undefined;
    }
    interface LodashSampleSize {
        (n: number): LodashSampleSize1x1;
        <T>(n: lodash.__, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): LodashSampleSize1x2<T>;
        <T>(n: number, collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T[];
        <T extends object>(n: lodash.__, collection: T | null | undefined): LodashSampleSize2x2<T>;
        <T extends object>(n: number, collection: T | null | undefined): Array<T[keyof T]>;
    }
    interface LodashSampleSize1x1 {
        <T>(collection: lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T[];
        <T extends object>(collection: T | null | undefined): Array<T[keyof T]>;
    }
    type LodashSampleSize1x2<T> = (n: number) => T[];
    type LodashSampleSize2x2<T> = (n: number) => Array<T[keyof T]>;
    interface LodashSetWith {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x1<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x2;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashSetWith1x3<T>;
        (customizer: lodash.__, path: lodash.__, value: any): LodashSetWith1x4;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, value: any): LodashSetWith1x5<T>;
        (customizer: lodash.__, path: lodash.PropertyPath, value: any): LodashSetWith1x6;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, value: any): LodashSetWith1x7<T>;
        <T extends object>(customizer: lodash.__, path: lodash.__, value: lodash.__, object: T): LodashSetWith1x8<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, value: lodash.__, object: T): LodashSetWith1x9<T>;
        <T extends object>(customizer: lodash.__, path: lodash.PropertyPath, value: lodash.__, object: T): LodashSetWith1x10<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, value: lodash.__, object: T): LodashSetWith1x11<T>;
        <T extends object>(customizer: lodash.__, path: lodash.__, value: any, object: T): LodashSetWith1x12<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, value: any, object: T): LodashSetWith1x13<T>;
        <T extends object>(customizer: lodash.__, path: lodash.PropertyPath, value: any, object: T): LodashSetWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, value: any, object: T): T;
    }
    interface LodashSetWith1x1<T> {
        (path: lodash.PropertyPath): LodashSetWith1x3<T>;
        (path: lodash.__, value: any): LodashSetWith1x5<T>;
        (path: lodash.PropertyPath, value: any): LodashSetWith1x7<T>;
        (path: lodash.__, value: lodash.__, object: T): LodashSetWith1x9<T>;
        (path: lodash.PropertyPath, value: lodash.__, object: T): LodashSetWith1x11<T>;
        (path: lodash.__, value: any, object: T): LodashSetWith1x13<T>;
        (path: lodash.PropertyPath, value: any, object: T): T;
    }
    interface LodashSetWith1x2 {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x3<T>;
        (customizer: lodash.__, value: any): LodashSetWith1x6;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, value: any): LodashSetWith1x7<T>;
        <T extends object>(customizer: lodash.__, value: lodash.__, object: T): LodashSetWith1x10<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, value: lodash.__, object: T): LodashSetWith1x11<T>;
        <T extends object>(customizer: lodash.__, value: any, object: T): LodashSetWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, value: any, object: T): T;
    }
    interface LodashSetWith1x3<T> {
        (value: any): LodashSetWith1x7<T>;
        (value: lodash.__, object: T): LodashSetWith1x11<T>;
        (value: any, object: T): T;
    }
    interface LodashSetWith1x4 {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x5<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x6;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashSetWith1x7<T>;
        <T extends object>(customizer: lodash.__, path: lodash.__, object: T): LodashSetWith1x12<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, object: T): LodashSetWith1x13<T>;
        <T extends object>(customizer: lodash.__, path: lodash.PropertyPath, object: T): LodashSetWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, object: T): T;
    }
    interface LodashSetWith1x5<T> {
        (path: lodash.PropertyPath): LodashSetWith1x7<T>;
        (path: lodash.__, object: T): LodashSetWith1x13<T>;
        (path: lodash.PropertyPath, object: T): T;
    }
    interface LodashSetWith1x6 {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x7<T>;
        <T extends object>(customizer: lodash.__, object: T): LodashSetWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, object: T): T;
    }
    type LodashSetWith1x7<T> = (object: T) => T;
    interface LodashSetWith1x8<T> {
        (customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x9<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x10<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashSetWith1x11<T>;
        (customizer: lodash.__, path: lodash.__, value: any): LodashSetWith1x12<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.__, value: any): LodashSetWith1x13<T>;
        (customizer: lodash.__, path: lodash.PropertyPath, value: any): LodashSetWith1x14<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, value: any): T;
    }
    interface LodashSetWith1x9<T> {
        (path: lodash.PropertyPath): LodashSetWith1x11<T>;
        (path: lodash.__, value: any): LodashSetWith1x13<T>;
        (path: lodash.PropertyPath, value: any): T;
    }
    interface LodashSetWith1x10<T> {
        (customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x11<T>;
        (customizer: lodash.__, value: any): LodashSetWith1x14<T>;
        (customizer: lodash.SetWithCustomizer<T>, value: any): T;
    }
    type LodashSetWith1x11<T> = (value: any) => T;
    interface LodashSetWith1x12<T> {
        (customizer: lodash.SetWithCustomizer<T>): LodashSetWith1x13<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashSetWith1x14<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): T;
    }
    type LodashSetWith1x13<T> = (path: lodash.PropertyPath) => T;
    type LodashSetWith1x14<T> = (customizer: lodash.SetWithCustomizer<T>) => T;
    interface LodashShuffle {
        <T>(collection: lodash.List<T> | null | undefined): T[];
        <T extends object>(collection: T | null | undefined): Array<T[keyof T]>;
    }
    type LodashSize = (collection: object | string | null | undefined) => number;
    interface LodashSlice {
        (start: number): LodashSlice1x1;
        (start: lodash.__, end: number): LodashSlice1x2;
        (start: number, end: number): LodashSlice1x3;
        <T>(start: lodash.__, end: lodash.__, array: lodash.List<T> | null | undefined): LodashSlice1x4<T>;
        <T>(start: number, end: lodash.__, array: lodash.List<T> | null | undefined): LodashSlice1x5<T>;
        <T>(start: lodash.__, end: number, array: lodash.List<T> | null | undefined): LodashSlice1x6<T>;
        <T>(start: number, end: number, array: lodash.List<T> | null | undefined): T[];
    }
    interface LodashSlice1x1 {
        (end: number): LodashSlice1x3;
        <T>(end: lodash.__, array: lodash.List<T> | null | undefined): LodashSlice1x5<T>;
        <T>(end: number, array: lodash.List<T> | null | undefined): T[];
    }
    interface LodashSlice1x2 {
        (start: number): LodashSlice1x3;
        <T>(start: lodash.__, array: lodash.List<T> | null | undefined): LodashSlice1x6<T>;
        <T>(start: number, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashSlice1x3 = <T>(array: lodash.List<T> | null | undefined) => T[];
    interface LodashSlice1x4<T> {
        (start: number): LodashSlice1x5<T>;
        (start: lodash.__, end: number): LodashSlice1x6<T>;
        (start: number, end: number): T[];
    }
    type LodashSlice1x5<T> = (end: number) => T[];
    type LodashSlice1x6<T> = (start: number) => T[];
    type LodashSnakeCase = (string: string) => string;
    interface LodashSortBy {
        <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>): LodashSortBy1x1<T>;
        <T>(iteratees: lodash.__, collection: lodash.List<T> | null | undefined): LodashSortBy1x2<T>;
        <T>(iteratees: lodash.Many<lodash.ValueIteratee<T>>, collection: lodash.List<T> | null | undefined): T[];
        <T extends object>(iteratees: lodash.__, collection: T | null | undefined): LodashSortBy2x2<T>;
        <T extends object>(iteratees: lodash.Many<lodash.ValueIteratee<T[keyof T]>>, collection: T | null | undefined): Array<T[keyof T]>;
    }
    type LodashSortBy1x1<T> = (collection: lodash.List<T> | object | null | undefined) => T[];
    type LodashSortBy1x2<T> = (iteratees: lodash.Many<lodash.ValueIteratee<T>>) => T[];
    type LodashSortBy2x2<T> = (iteratees: lodash.Many<lodash.ValueIteratee<T[keyof T]>>) => Array<T[keyof T]>;
    interface LodashSortedIndex {
        <T>(value: T): LodashSortedIndex1x1<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndex1x2<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashSortedIndex1x1<T> = (array: lodash.List<T> | null | undefined) => number;
    type LodashSortedIndex1x2<T> = (value: T) => number;
    interface LodashSortedIndexBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashSortedIndexBy1x1<T>;
        <T>(iteratee: lodash.__, value: T): LodashSortedIndexBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, value: T): LodashSortedIndexBy1x3<T>;
        <T>(iteratee: lodash.__, value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndexBy1x4<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndexBy1x5<T>;
        <T>(iteratee: lodash.__, value: T, array: lodash.List<T> | null | undefined): LodashSortedIndexBy1x6<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, value: T, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashSortedIndexBy1x1<T> {
        (value: T): LodashSortedIndexBy1x3<T>;
        (value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndexBy1x5<T>;
        (value: T, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashSortedIndexBy1x2<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashSortedIndexBy1x3<T>;
        (iteratee: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndexBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): number;
    }
    type LodashSortedIndexBy1x3<T> = (array: lodash.List<T> | null | undefined) => number;
    interface LodashSortedIndexBy1x4<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashSortedIndexBy1x5<T>;
        (iteratee: lodash.__, value: T): LodashSortedIndexBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, value: T): number;
    }
    type LodashSortedIndexBy1x5<T> = (value: T) => number;
    type LodashSortedIndexBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => number;
    interface LodashSortedIndexOf {
        <T>(value: T): LodashSortedIndexOf1x1<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedIndexOf1x2<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashSortedIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
    type LodashSortedIndexOf1x2<T> = (value: T) => number;
    interface LodashSortedLastIndex {
        <T>(value: T): LodashSortedLastIndex1x1<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndex1x2<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashSortedLastIndex1x1<T> = (array: lodash.List<T> | null | undefined) => number;
    type LodashSortedLastIndex1x2<T> = (value: T) => number;
    interface LodashSortedLastIndexBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashSortedLastIndexBy1x1<T>;
        <T>(iteratee: lodash.__, value: T): LodashSortedLastIndexBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, value: T): LodashSortedLastIndexBy1x3<T>;
        <T>(iteratee: lodash.__, value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndexBy1x4<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndexBy1x5<T>;
        <T>(iteratee: lodash.__, value: T, array: lodash.List<T> | null | undefined): LodashSortedLastIndexBy1x6<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, value: T, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashSortedLastIndexBy1x1<T> {
        (value: T): LodashSortedLastIndexBy1x3<T>;
        (value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndexBy1x5<T>;
        (value: T, array: lodash.List<T> | null | undefined): number;
    }
    interface LodashSortedLastIndexBy1x2<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashSortedLastIndexBy1x3<T>;
        (iteratee: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndexBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): number;
    }
    type LodashSortedLastIndexBy1x3<T> = (array: lodash.List<T> | null | undefined) => number;
    interface LodashSortedLastIndexBy1x4<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashSortedLastIndexBy1x5<T>;
        (iteratee: lodash.__, value: T): LodashSortedLastIndexBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, value: T): number;
    }
    type LodashSortedLastIndexBy1x5<T> = (value: T) => number;
    type LodashSortedLastIndexBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => number;
    interface LodashSortedLastIndexOf {
        <T>(value: T): LodashSortedLastIndexOf1x1<T>;
        <T>(value: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedLastIndexOf1x2<T>;
        <T>(value: T, array: lodash.List<T> | null | undefined): number;
    }
    type LodashSortedLastIndexOf1x1<T> = (array: lodash.List<T> | null | undefined) => number;
    type LodashSortedLastIndexOf1x2<T> = (value: T) => number;
    type LodashSortedUniq = <T>(array: lodash.List<T> | null | undefined) => T[];
    interface LodashSortedUniqBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashSortedUniqBy1x1<T>;
        <T>(iteratee: lodash.__, array: lodash.List<T> | null | undefined): LodashSortedUniqBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashSortedUniqBy1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
    type LodashSortedUniqBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
    interface LodashSplit {
        (separator: RegExp | string): LodashSplit1x1;
        (separator: lodash.__, string: string | null | undefined): LodashSplit1x2;
        (separator: RegExp | string, string: string | null | undefined): string[];
    }
    type LodashSplit1x1 = (string: string | null | undefined) => string[];
    type LodashSplit1x2 = (separator: RegExp | string) => string[];
    type LodashSpread = <TResult>(func: (...args: any[]) => TResult) => (...args: any[]) => TResult;
    interface LodashSpreadFrom {
        (start: number): LodashSpreadFrom1x1;
        <TResult>(start: lodash.__, func: (...args: any[]) => TResult): LodashSpreadFrom1x2<TResult>;
        <TResult>(start: number, func: (...args: any[]) => TResult): (...args: any[]) => TResult;
    }
    type LodashSpreadFrom1x1 = <TResult>(func: (...args: any[]) => TResult) => (...args: any[]) => TResult;
    type LodashSpreadFrom1x2<TResult> = (start: number) => (...args: any[]) => TResult;
    type LodashStartCase = (string: string) => string;
    interface LodashStartsWith {
        (target: string): LodashStartsWith1x1;
        (target: lodash.__, string: string): LodashStartsWith1x2;
        (target: string, string: string): boolean;
    }
    type LodashStartsWith1x1 = (string: string) => boolean;
    type LodashStartsWith1x2 = (target: string) => boolean;
    type LodashStubArray = () => any[];
    type LodashStubObject = () => any;
    type LodashStubString = () => string;
    type LodashStubTrue = () => true;
    interface LodashSubtract {
        (minuend: number): LodashSubtract1x1;
        (minuend: lodash.__, subtrahend: number): LodashSubtract1x2;
        (minuend: number, subtrahend: number): number;
    }
    type LodashSubtract1x1 = (subtrahend: number) => number;
    type LodashSubtract1x2 = (minuend: number) => number;
    type LodashSum = (collection: lodash.List<any> | null | undefined) => number;
    interface LodashSumBy {
        <T>(iteratee: ((value: T) => number) | string): LodashSumBy1x1<T>;
        <T>(iteratee: lodash.__, collection: lodash.List<T> | null | undefined): LodashSumBy1x2<T>;
        <T>(iteratee: ((value: T) => number) | string, collection: lodash.List<T> | null | undefined): number;
    }
    type LodashSumBy1x1<T> = (collection: lodash.List<T> | null | undefined) => number;
    type LodashSumBy1x2<T> = (iteratee: ((value: T) => number) | string) => number;
    interface LodashXor {
        <T>(arrays2: lodash.List<T> | null | undefined): LodashXor1x1<T>;
        <T>(arrays2: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXor1x2<T>;
        <T>(arrays2: lodash.List<T> | null | undefined, arrays: lodash.List<T> | null | undefined): T[];
    }
    type LodashXor1x1<T> = (arrays: lodash.List<T> | null | undefined) => T[];
    type LodashXor1x2<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashXorBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashXorBy1x1<T>;
        <T>(iteratee: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXorBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, arrays: lodash.List<T> | null | undefined): LodashXorBy1x3<T>;
        <T>(iteratee: lodash.__, arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorBy1x4<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorBy1x5<T>;
        <T>(iteratee: lodash.__, arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): LodashXorBy1x6<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashXorBy1x1<T> {
        (arrays: lodash.List<T> | null | undefined): LodashXorBy1x3<T>;
        (arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorBy1x5<T>;
        (arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashXorBy1x2<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashXorBy1x3<T>;
        (iteratee: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, arrays2: lodash.List<T> | null | undefined): T[];
    }
    type LodashXorBy1x3<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashXorBy1x4<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashXorBy1x5<T>;
        (iteratee: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXorBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, arrays: lodash.List<T> | null | undefined): T[];
    }
    type LodashXorBy1x5<T> = (arrays: lodash.List<T> | null | undefined) => T[];
    type LodashXorBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
    interface LodashXorWith {
        <T>(comparator: lodash.Comparator<T>): LodashXorWith1x1<T>;
        <T>(comparator: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXorWith1x2<T>;
        <T>(comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined): LodashXorWith1x3<T>;
        <T>(comparator: lodash.__, arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorWith1x4<T>;
        <T>(comparator: lodash.Comparator<T>, arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorWith1x5<T>;
        <T>(comparator: lodash.__, arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): LodashXorWith1x6<T>;
        <T>(comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashXorWith1x1<T> {
        (arrays: lodash.List<T> | null | undefined): LodashXorWith1x3<T>;
        (arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorWith1x5<T>;
        (arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashXorWith1x2<T> {
        (comparator: lodash.Comparator<T>): LodashXorWith1x3<T>;
        (comparator: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashXorWith1x6<T>;
        (comparator: lodash.Comparator<T>, arrays2: lodash.List<T> | null | undefined): T[];
    }
    type LodashXorWith1x3<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashXorWith1x4<T> {
        (comparator: lodash.Comparator<T>): LodashXorWith1x5<T>;
        (comparator: lodash.__, arrays: lodash.List<T> | null | undefined): LodashXorWith1x6<T>;
        (comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined): T[];
    }
    type LodashXorWith1x5<T> = (arrays: lodash.List<T> | null | undefined) => T[];
    type LodashXorWith1x6<T> = (comparator: lodash.Comparator<T>) => T[];
    type LodashTail = <T>(array: lodash.List<T> | null | undefined) => T[];
    interface LodashTake {
        (n: number): LodashTake1x1;
        <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashTake1x2<T>;
        <T>(n: number, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashTake1x1 = <T>(array: lodash.List<T> | null | undefined) => T[];
    type LodashTake1x2<T> = (n: number) => T[];
    interface LodashTakeRight {
        (n: number): LodashTakeRight1x1;
        <T>(n: lodash.__, array: lodash.List<T> | null | undefined): LodashTakeRight1x2<T>;
        <T>(n: number, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashTakeRight1x1 = <T>(array: lodash.List<T> | null | undefined) => T[];
    type LodashTakeRight1x2<T> = (n: number) => T[];
    interface LodashTakeRightWhile {
        <T>(predicate: lodash.ValueIteratee<T>): LodashTakeRightWhile1x1<T>;
        <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashTakeRightWhile1x2<T>;
        <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashTakeRightWhile1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
    type LodashTakeRightWhile1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
    interface LodashTakeWhile {
        <T>(predicate: lodash.ValueIteratee<T>): LodashTakeWhile1x1<T>;
        <T>(predicate: lodash.__, array: lodash.List<T> | null | undefined): LodashTakeWhile1x2<T>;
        <T>(predicate: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashTakeWhile1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
    type LodashTakeWhile1x2<T> = (predicate: lodash.ValueIteratee<T>) => T[];
    interface LodashTap {
        <T>(interceptor: (value: T) => void): LodashTap1x1<T>;
        <T>(interceptor: lodash.__, value: T): LodashTap1x2<T>;
        <T>(interceptor: (value: T) => void, value: T): T;
    }
    type LodashTap1x1<T> = (value: T) => T;
    type LodashTap1x2<T> = (interceptor: (value: T) => void) => T;
    type LodashTemplate = (string: string) => lodash.TemplateExecutor;
    interface LodashThrottle {
        (wait: number): LodashThrottle1x1;
        <T extends (...args: any) => any>(wait: lodash.__, func: T): LodashThrottle1x2<T>;
        <T extends (...args: any) => any>(wait: number, func: T): lodash.DebouncedFuncLeading<T>;
    }
    type LodashThrottle1x1 = <T extends (...args: any) => any>(func: T) => lodash.DebouncedFuncLeading<T>;
    type LodashThrottle1x2<T extends (...args: any) => any> = (wait: number) => lodash.DebouncedFuncLeading<T>;
    interface LodashThru {
        <T, TResult>(interceptor: (value: T) => TResult): LodashThru1x1<T, TResult>;
        <T>(interceptor: lodash.__, value: T): LodashThru1x2<T>;
        <T, TResult>(interceptor: (value: T) => TResult, value: T): TResult;
    }
    type LodashThru1x1<T, TResult> = (value: T) => TResult;
    type LodashThru1x2<T> = <TResult>(interceptor: (value: T) => TResult) => TResult;
    interface LodashTimes {
        <TResult>(iteratee: (num: number) => TResult): LodashTimes1x1<TResult>;
        (iteratee: lodash.__, n: number): LodashTimes1x2;
        <TResult>(iteratee: (num: number) => TResult, n: number): TResult[];
    }
    type LodashTimes1x1<TResult> = (n: number) => TResult[];
    type LodashTimes1x2 = <TResult>(iteratee: (num: number) => TResult) => TResult[];
    interface LodashToArray {
        <T>(value:  lodash.Dictionary<T> | lodash.NumericDictionary<T> | null | undefined): T[];
        <T>(value: T): Array<T[keyof T]>;
        (): any[];
    }
    type LodashToFinite = (value: any) => number;
    type LodashToInteger = (value: any) => number;
    type LodashToLength = (value: any) => number;
    type LodashToLower = <T extends string = string>(string: T) => Lowercase<T>;
    type LodashToNumber = (value: any) => number;
    type LodashToPath = (value: any) => string[];
    type LodashToPlainObject = (value: any) => any;
    type LodashToSafeInteger = (value: any) => number;
    type LodashToString = (value: any) => string;
    type LodashToUpper = <T extends string = string>(string: T) => Uppercase<T>;
    interface LodashTransform {
        <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>): LodashTransform1x1<T, TResult>;
        <TResult>(iteratee: lodash.__, accumulator: TResult): LodashTransform1x2<TResult>;
        <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, accumulator: TResult): LodashTransform1x3<T, TResult>;
        <T>(iteratee: lodash.__, accumulator: lodash.__, object: readonly T[]): LodashTransform1x4<T>;
        <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, accumulator: lodash.__, object: readonly T[]): LodashTransform1x5<TResult>;
        <T, TResult>(iteratee: lodash.__, accumulator: TResult, object: readonly T[]): LodashTransform1x6<T, TResult>;
        <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, accumulator: TResult, object: readonly T[] | lodash.Dictionary<T>): TResult;
        <T>(iteratee: lodash.__, accumulator: lodash.__, object: lodash.Dictionary<T>): LodashTransform2x4<T>;
        <T, TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, accumulator: lodash.__, object: lodash.Dictionary<T>): LodashTransform2x5<TResult>;
        <T, TResult>(iteratee: lodash.__, accumulator: TResult, object: lodash.Dictionary<T>): LodashTransform2x6<T, TResult>;
    }
    interface LodashTransform1x1<T, TResult> {
        (accumulator: TResult): LodashTransform1x3<T, TResult>;
        (accumulator: lodash.__, object: readonly T[]): LodashTransform1x5<TResult>;
        (accumulator: TResult, object: readonly T[] | lodash.Dictionary<T>): TResult;
        (accumulator: lodash.__, object: lodash.Dictionary<T>): LodashTransform2x5<TResult>;
    }
    interface LodashTransform1x2<TResult> {
        <T>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>): LodashTransform1x3<T, TResult>;
        <T>(iteratee: lodash.__, object: readonly T[]): LodashTransform1x6<T, TResult>;
        <T>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, object: readonly T[] | lodash.Dictionary<T>): TResult;
        <T>(iteratee: lodash.__, object: lodash.Dictionary<T>): LodashTransform2x6<T, TResult>;
    }
    type LodashTransform1x3<T, TResult> = (object: readonly T[] | lodash.Dictionary<T>) => TResult;
    interface LodashTransform1x4<T> {
        <TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>): LodashTransform1x5<TResult>;
        <TResult>(iteratee: lodash.__, accumulator: TResult): LodashTransform1x6<T, TResult>;
        <TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, accumulator: TResult): TResult;
    }
    type LodashTransform1x5<TResult> = (accumulator: TResult) => TResult;
    type LodashTransform1x6<T, TResult> = (iteratee: lodash.MemoVoidIteratorCapped<T, TResult>) => TResult;
    interface LodashTransform2x4<T> {
        <TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>): LodashTransform2x5<TResult>;
        <TResult>(iteratee: lodash.__, accumulator: TResult): LodashTransform2x6<T, TResult>;
        <TResult>(iteratee: lodash.MemoVoidIteratorCapped<T, TResult>, accumulator: TResult): TResult;
    }
    type LodashTransform2x5<TResult> = (accumulator: TResult) => TResult;
    type LodashTransform2x6<T, TResult> = (iteratee: lodash.MemoVoidIteratorCapped<T, TResult>) => TResult;
    type LodashTrim = (string: string) => string;
    interface LodashTrimChars {
        (chars: string): LodashTrimChars1x1;
        (chars: lodash.__, string: string): LodashTrimChars1x2;
        (chars: string, string: string): string;
    }
    type LodashTrimChars1x1 = (string: string) => string;
    type LodashTrimChars1x2 = (chars: string) => string;
    interface LodashTrimCharsEnd {
        (chars: string): LodashTrimCharsEnd1x1;
        (chars: lodash.__, string: string): LodashTrimCharsEnd1x2;
        (chars: string, string: string): string;
    }
    type LodashTrimCharsEnd1x1 = (string: string) => string;
    type LodashTrimCharsEnd1x2 = (chars: string) => string;
    interface LodashTrimCharsStart {
        (chars: string): LodashTrimCharsStart1x1;
        (chars: lodash.__, string: string): LodashTrimCharsStart1x2;
        (chars: string, string: string): string;
    }
    type LodashTrimCharsStart1x1 = (string: string) => string;
    type LodashTrimCharsStart1x2 = (chars: string) => string;
    type LodashTrimEnd = (string: string) => string;
    type LodashTrimStart = (string: string) => string;
    interface LodashTruncate {
        (options: lodash.TruncateOptions): LodashTruncate1x1;
        (options: lodash.__, string: string): LodashTruncate1x2;
        (options: lodash.TruncateOptions, string: string): string;
    }
    type LodashTruncate1x1 = (string: string) => string;
    type LodashTruncate1x2 = (options: lodash.TruncateOptions) => string;
    type LodashUnapply = (func: (...args: any[]) => any) => (...args: any[]) => any;
    type LodashUnary = <T, TResult>(func: (arg1: T, ...args: any[]) => TResult) => (arg1: T) => TResult;
    type LodashUnescape = (string: string) => string;
    interface LodashUnion {
        <T>(arrays2: lodash.List<T> | null | undefined): LodashUnion1x1<T>;
        <T>(arrays2: lodash.__, arrays: lodash.List<T> | null | undefined): LodashUnion1x2<T>;
        <T>(arrays2: lodash.List<T> | null | undefined, arrays: lodash.List<T> | null | undefined): T[];
    }
    type LodashUnion1x1<T> = (arrays: lodash.List<T> | null | undefined) => T[];
    type LodashUnion1x2<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashUnionBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashUnionBy1x1<T>;
        <T>(iteratee: lodash.__, arrays1: lodash.List<T> | null | undefined): LodashUnionBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, arrays1: lodash.List<T> | null | undefined): LodashUnionBy1x3<T>;
        <T>(iteratee: lodash.__, arrays1: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionBy1x4<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, arrays1: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionBy1x5<T>;
        <T>(iteratee: lodash.__, arrays1: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): LodashUnionBy1x6<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, arrays1: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashUnionBy1x1<T> {
        (arrays1: lodash.List<T> | null | undefined): LodashUnionBy1x3<T>;
        (arrays1: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionBy1x5<T>;
        (arrays1: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashUnionBy1x2<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashUnionBy1x3<T>;
        (iteratee: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, arrays2: lodash.List<T> | null | undefined): T[];
    }
    type LodashUnionBy1x3<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashUnionBy1x4<T> {
        (iteratee: lodash.ValueIteratee<T>): LodashUnionBy1x5<T>;
        (iteratee: lodash.__, arrays1: lodash.List<T> | null | undefined): LodashUnionBy1x6<T>;
        (iteratee: lodash.ValueIteratee<T>, arrays1: lodash.List<T> | null | undefined): T[];
    }
    type LodashUnionBy1x5<T> = (arrays1: lodash.List<T> | null | undefined) => T[];
    type LodashUnionBy1x6<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
    interface LodashUnionWith {
        <T>(comparator: lodash.Comparator<T>): LodashUnionWith1x1<T>;
        <T>(comparator: lodash.__, arrays: lodash.List<T> | null | undefined): LodashUnionWith1x2<T>;
        <T>(comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined): LodashUnionWith1x3<T>;
        <T>(comparator: lodash.__, arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionWith1x4<T>;
        <T>(comparator: lodash.Comparator<T>, arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionWith1x5<T>;
        <T>(comparator: lodash.__, arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): LodashUnionWith1x6<T>;
        <T>(comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashUnionWith1x1<T> {
        (arrays: lodash.List<T> | null | undefined): LodashUnionWith1x3<T>;
        (arrays: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionWith1x5<T>;
        (arrays: lodash.List<T> | null | undefined, arrays2: lodash.List<T> | null | undefined): T[];
    }
    interface LodashUnionWith1x2<T> {
        (comparator: lodash.Comparator<T>): LodashUnionWith1x3<T>;
        (comparator: lodash.__, arrays2: lodash.List<T> | null | undefined): LodashUnionWith1x6<T>;
        (comparator: lodash.Comparator<T>, arrays2: lodash.List<T> | null | undefined): T[];
    }
    type LodashUnionWith1x3<T> = (arrays2: lodash.List<T> | null | undefined) => T[];
    interface LodashUnionWith1x4<T> {
        (comparator: lodash.Comparator<T>): LodashUnionWith1x5<T>;
        (comparator: lodash.__, arrays: lodash.List<T> | null | undefined): LodashUnionWith1x6<T>;
        (comparator: lodash.Comparator<T>, arrays: lodash.List<T> | null | undefined): T[];
    }
    type LodashUnionWith1x5<T> = (arrays: lodash.List<T> | null | undefined) => T[];
    type LodashUnionWith1x6<T> = (comparator: lodash.Comparator<T>) => T[];
    type LodashUniq = <T>(array: lodash.List<T> | null | undefined) => T[];
    interface LodashUniqBy {
        <T>(iteratee: lodash.ValueIteratee<T>): LodashUniqBy1x1<T>;
        <T>(iteratee: lodash.__, array: lodash.List<T> | null | undefined): LodashUniqBy1x2<T>;
        <T>(iteratee: lodash.ValueIteratee<T>, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashUniqBy1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
    type LodashUniqBy1x2<T> = (iteratee: lodash.ValueIteratee<T>) => T[];
    type LodashUniqueId = (prefix: string) => string;
    interface LodashUniqWith {
        <T>(comparator: lodash.Comparator<T>): LodashUniqWith1x1<T>;
        <T>(comparator: lodash.__, array: lodash.List<T> | null | undefined): LodashUniqWith1x2<T>;
        <T>(comparator: lodash.Comparator<T>, array: lodash.List<T> | null | undefined): T[];
    }
    type LodashUniqWith1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
    type LodashUniqWith1x2<T> = (comparator: lodash.Comparator<T>) => T[];
    type LodashUnzip = <T>(array: T[][] | lodash.List<lodash.List<T>> | null | undefined) => T[][];
    interface LodashUnzipWith {
        <T, TResult>(iteratee: (...values: T[]) => TResult): LodashUnzipWith1x1<T, TResult>;
        <T>(iteratee: lodash.__, array: lodash.List<lodash.List<T>> | null | undefined): LodashUnzipWith1x2<T>;
        <T, TResult>(iteratee: (...values: T[]) => TResult, array: lodash.List<lodash.List<T>> | null | undefined): TResult[];
    }
    type LodashUnzipWith1x1<T, TResult> = (array: lodash.List<lodash.List<T>> | null | undefined) => TResult[];
    type LodashUnzipWith1x2<T> = <TResult>(iteratee: (...values: T[]) => TResult) => TResult[];
    interface LodashUpdate {
        (path: lodash.PropertyPath): LodashUpdate1x1;
        (path: lodash.__, updater: (value: any) => any): LodashUpdate1x2;
        (path: lodash.PropertyPath, updater: (value: any) => any): LodashUpdate1x3;
        (path: lodash.__, updater: lodash.__, object: object): LodashUpdate1x4;
        (path: lodash.PropertyPath, updater: lodash.__, object: object): LodashUpdate1x5;
        (path: lodash.__, updater: (value: any) => any, object: object): LodashUpdate1x6;
        (path: lodash.PropertyPath, updater: (value: any) => any, object: object): any;
    }
    interface LodashUpdate1x1 {
        (updater: (value: any) => any): LodashUpdate1x3;
        (updater: lodash.__, object: object): LodashUpdate1x5;
        (updater: (value: any) => any, object: object): any;
    }
    interface LodashUpdate1x2 {
        (path: lodash.PropertyPath): LodashUpdate1x3;
        (path: lodash.__, object: object): LodashUpdate1x6;
        (path: lodash.PropertyPath, object: object): any;
    }
    type LodashUpdate1x3 = (object: object) => any;
    interface LodashUpdate1x4 {
        (path: lodash.PropertyPath): LodashUpdate1x5;
        (path: lodash.__, updater: (value: any) => any): LodashUpdate1x6;
        (path: lodash.PropertyPath, updater: (value: any) => any): any;
    }
    type LodashUpdate1x5 = (updater: (value: any) => any) => any;
    type LodashUpdate1x6 = (path: lodash.PropertyPath) => any;
    interface LodashUpdateWith {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x1<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x2;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashUpdateWith1x3<T>;
        (customizer: lodash.__, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x4;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x5<T>;
        (customizer: lodash.__, path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x6;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x7<T>;
        <T extends object>(customizer: lodash.__, path: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x8<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x9<T>;
        <T extends object>(customizer: lodash.__, path: lodash.PropertyPath, updater: lodash.__, object: T): LodashUpdateWith1x10<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, updater: lodash.__, object: T): LodashUpdateWith1x11<T>;
        <T extends object>(customizer: lodash.__, path: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x12<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x13<T>;
        <T extends object>(customizer: lodash.__, path: lodash.PropertyPath, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, updater: (oldValue: any) => any, object: T): T;
    }
    interface LodashUpdateWith1x1<T> {
        (path: lodash.PropertyPath): LodashUpdateWith1x3<T>;
        (path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x5<T>;
        (path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x7<T>;
        (path: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x9<T>;
        (path: lodash.PropertyPath, updater: lodash.__, object: T): LodashUpdateWith1x11<T>;
        (path: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x13<T>;
        (path: lodash.PropertyPath, updater: (oldValue: any) => any, object: T): T;
    }
    interface LodashUpdateWith1x2 {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x3<T>;
        (customizer: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x6;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, updater: (oldValue: any) => any): LodashUpdateWith1x7<T>;
        <T extends object>(customizer: lodash.__, updater: lodash.__, object: T): LodashUpdateWith1x10<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, updater: lodash.__, object: T): LodashUpdateWith1x11<T>;
        <T extends object>(customizer: lodash.__, updater: (oldValue: any) => any, object: T): LodashUpdateWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, updater: (oldValue: any) => any, object: T): T;
    }
    interface LodashUpdateWith1x3<T> {
        (updater: (oldValue: any) => any): LodashUpdateWith1x7<T>;
        (updater: lodash.__, object: T): LodashUpdateWith1x11<T>;
        (updater: (oldValue: any) => any, object: T): T;
    }
    interface LodashUpdateWith1x4 {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x5<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x6;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashUpdateWith1x7<T>;
        <T extends object>(customizer: lodash.__, path: lodash.__, object: T): LodashUpdateWith1x12<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.__, object: T): LodashUpdateWith1x13<T>;
        <T extends object>(customizer: lodash.__, path: lodash.PropertyPath, object: T): LodashUpdateWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, object: T): T;
    }
    interface LodashUpdateWith1x5<T> {
        (path: lodash.PropertyPath): LodashUpdateWith1x7<T>;
        (path: lodash.__, object: T): LodashUpdateWith1x13<T>;
        (path: lodash.PropertyPath, object: T): T;
    }
    interface LodashUpdateWith1x6 {
        <T extends object>(customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x7<T>;
        <T extends object>(customizer: lodash.__, object: T): LodashUpdateWith1x14<T>;
        <T extends object>(customizer: lodash.SetWithCustomizer<T>, object: T): T;
    }
    type LodashUpdateWith1x7<T> = (object: T) => T;
    interface LodashUpdateWith1x8<T> {
        (customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x9<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x10<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): LodashUpdateWith1x11<T>;
        (customizer: lodash.__, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x12<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x13<T>;
        (customizer: lodash.__, path: lodash.PropertyPath, updater: (oldValue: any) => any): LodashUpdateWith1x14<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath, updater: (oldValue: any) => any): T;
    }
    interface LodashUpdateWith1x9<T> {
        (path: lodash.PropertyPath): LodashUpdateWith1x11<T>;
        (path: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x13<T>;
        (path: lodash.PropertyPath, updater: (oldValue: any) => any): T;
    }
    interface LodashUpdateWith1x10<T> {
        (customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x11<T>;
        (customizer: lodash.__, updater: (oldValue: any) => any): LodashUpdateWith1x14<T>;
        (customizer: lodash.SetWithCustomizer<T>, updater: (oldValue: any) => any): T;
    }
    type LodashUpdateWith1x11<T> = (updater: (oldValue: any) => any) => T;
    interface LodashUpdateWith1x12<T> {
        (customizer: lodash.SetWithCustomizer<T>): LodashUpdateWith1x13<T>;
        (customizer: lodash.__, path: lodash.PropertyPath): LodashUpdateWith1x14<T>;
        (customizer: lodash.SetWithCustomizer<T>, path: lodash.PropertyPath): T;
    }
    type LodashUpdateWith1x13<T> = (path: lodash.PropertyPath) => T;
    type LodashUpdateWith1x14<T> = (customizer: lodash.SetWithCustomizer<T>) => T;
    type LodashUpperCase = (string: string) => string;
    type LodashUpperFirst = <T extends string = string>(string: T) => Capitalize<T>;
    interface LodashValues {
        <T>(object: lodash.Dictionary<T> | lodash.NumericDictionary<T> | lodash.List<T> | null | undefined): T[];
        <T extends object>(object: T | null | undefined): Array<T[keyof T]>;
        (object: any): any[];
    }
    interface LodashValuesIn {
        <T>(object: lodash.Dictionary<T> | lodash.NumericDictionary<T> | lodash.List<T> | null | undefined): T[];
        <T extends object>(object: T | null | undefined): Array<T[keyof T]>;
    }
    interface LodashWithout {
        <T>(values: readonly T[]): LodashWithout1x1<T>;
        <T>(values: lodash.__, array: lodash.List<T> | null | undefined): LodashWithout1x2<T>;
        <T>(values: readonly T[], array: lodash.List<T> | null | undefined): T[];
    }
    type LodashWithout1x1<T> = (array: lodash.List<T> | null | undefined) => T[];
    type LodashWithout1x2<T> = (values: readonly T[]) => T[];
    type LodashWords = (string: string) => string[];
    interface LodashWrap {
        <T, TArgs, TResult>(wrapper: (value: T, ...args: TArgs[]) => TResult): LodashWrap1x1<T, TArgs, TResult>;
        <T>(wrapper: lodash.__, value: T): LodashWrap1x2<T>;
        <T, TArgs, TResult>(wrapper: (value: T, ...args: TArgs[]) => TResult, value: T): (...args: TArgs[]) => TResult;
    }
    type LodashWrap1x1<T, TArgs, TResult> = (value: T) => (...args: TArgs[]) => TResult;
    type LodashWrap1x2<T> = <TArgs, TResult>(wrapper: (value: T, ...args: TArgs[]) => TResult) => (...args: TArgs[]) => TResult;
    interface LodashZip {
        <T1>(arrays1: lodash.List<T1>): LodashZip1x1<T1>;
        <T2>(arrays1: lodash.__, arrays2: lodash.List<T2>): LodashZip1x2<T2>;
        <T1, T2>(arrays1: lodash.List<T1>, arrays2: lodash.List<T2>): Array<[T1 | undefined, T2 | undefined]>;
    }
    type LodashZip1x1<T1> = <T2>(arrays2: lodash.List<T2>) => Array<[T1 | undefined, T2 | undefined]>;
    type LodashZip1x2<T2> = <T1>(arrays1: lodash.List<T1>) => Array<[T1 | undefined, T2 | undefined]>;
    interface LodashZipAll {
        <T1, T2>(arrays1: [lodash.List<T1>, lodash.List<T2>]): Array<[T1 | undefined, T2 | undefined]>;
        <T1, T2, T3>(arrays1: [lodash.List<T1>, lodash.List<T2>, lodash.List<T3>]): Array<[T1 | undefined, T2 | undefined, T3 | undefined]>;
        <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]>;
        <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]>;
        <T>(arrays: ReadonlyArray<lodash.List<T> | null | undefined>): Array<Array<T | undefined>>;
    }
    interface LodashZipObject {
        (props: lodash.List<lodash.PropertyName>): LodashZipObject1x1;
        <T>(props: lodash.__, values: lodash.List<T>): LodashZipObject1x2<T>;
        <T>(props: lodash.List<lodash.PropertyName>, values: lodash.List<T>): lodash.Dictionary<T>;
    }
    type LodashZipObject1x1 = <T>(values: lodash.List<T>) => lodash.Dictionary<T>;
    type LodashZipObject1x2<T> = (props: lodash.List<lodash.PropertyName>) => lodash.Dictionary<T>;
    interface LodashZipObjectDeep {
        (paths: lodash.List<lodash.PropertyPath>): LodashZipObjectDeep1x1;
        (paths: lodash.__, values: lodash.List<any>): LodashZipObjectDeep1x2;
        (paths: lodash.List<lodash.PropertyPath>, values: lodash.List<any>): object;
    }
    type LodashZipObjectDeep1x1 = (values: lodash.List<any>) => object;
    type LodashZipObjectDeep1x2 = (paths: lodash.List<lodash.PropertyPath>) => object;
    interface LodashZipWith {
        <T1, T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x1<T1, T2, TResult>;
        <T1>(iteratee: lodash.__, arrays1: lodash.List<T1>): LodashZipWith1x2<T1>;
        <T1, T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List<T1>): LodashZipWith1x3<T2, TResult>;
        <T2>(iteratee: lodash.__, arrays1: lodash.__, arrays2: lodash.List<T2>): LodashZipWith1x4<T2>;
        <T1, T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.__, arrays2: lodash.List<T2>): LodashZipWith1x5<T1, TResult>;
        <T1, T2>(iteratee: lodash.__, arrays1: lodash.List<T1>, arrays2: lodash.List<T2>): LodashZipWith1x6<T1, T2>;
        <T1, T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List<T1>, arrays2: lodash.List<T2>): TResult[];
    }
    interface LodashZipWith1x1<T1, T2, TResult> {
        (arrays1: lodash.List<T1>): LodashZipWith1x3<T2, TResult>;
        (arrays1: lodash.__, arrays2: lodash.List<T2>): LodashZipWith1x5<T1, TResult>;
        (arrays1: lodash.List<T1>, arrays2: lodash.List<T2>): TResult[];
    }
    interface LodashZipWith1x2<T1> {
        <T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x3<T2, TResult>;
        <T2>(iteratee: lodash.__, arrays2: lodash.List<T2>): LodashZipWith1x6<T1, T2>;
        <T2, TResult>(iteratee: (value1: T1, value2: T2) => TResult, arrays2: lodash.List<T2>): TResult[];
    }
    type LodashZipWith1x3<T2, TResult> = (arrays2: lodash.List<T2>) => TResult[];
    interface LodashZipWith1x4<T2> {
        <T1, TResult>(iteratee: (value1: T1, value2: T2) => TResult): LodashZipWith1x5<T1, TResult>;
        <T1>(iteratee: lodash.__, arrays1: lodash.List<T1>): LodashZipWith1x6<T1, T2>;
        <T1, TResult>(iteratee: (value1: T1, value2: T2) => TResult, arrays1: lodash.List<T1>): TResult[];
    }
    type LodashZipWith1x5<T1, TResult> = (arrays1: lodash.List<T1>) => TResult[];
    type LodashZipWith1x6<T1, T2> = <TResult>(iteratee: (value1: T1, value2: T2) => TResult) => TResult[];

    interface LoDashFp {
        add: LodashAdd;
        after: LodashAfter;
        all: LodashEvery;
        allPass: LodashOverEvery;
        always: LodashConstant;
        any: LodashSome;
        anyPass: LodashOverSome;
        apply: LodashApply;
        ary: LodashAry;
        assign: LodashAssign;
        assignAll: LodashAssignAll;
        assignAllWith: LodashAssignAllWith;
        assignIn: LodashAssignIn;
        assignInAll: LodashAssignInAll;
        assignInAllWith: LodashAssignInAllWith;
        assignInWith: LodashAssignInWith;
        assignWith: LodashAssignWith;
        assoc: LodashSet;
        assocPath: LodashSet;
        at: LodashAt;
        attempt: LodashAttempt;
        before: LodashBefore;
        bind: LodashBind;
        bindAll: LodashBindAll;
        bindKey: LodashBindKey;
        camelCase: LodashCamelCase;
        capitalize: LodashCapitalize;
        castArray: LodashCastArray;
        ceil: LodashCeil;
        chunk: LodashChunk;
        clamp: LodashClamp;
        clone: LodashClone;
        cloneDeep: LodashCloneDeep;
        cloneDeepWith: LodashCloneDeepWith;
        cloneWith: LodashCloneWith;
        compact: LodashCompact;
        complement: LodashNegate;
        compose: LodashFlowRight;
        concat: LodashConcat;
        cond: LodashCond;
        conforms: LodashConformsTo;
        conformsTo: LodashConformsTo;
        constant: LodashConstant;
        contains: LodashContains;
        countBy: LodashCountBy;
        create: LodashCreate;
        curry: LodashCurry;
        curryN: LodashCurryN;
        curryRight: LodashCurryRight;
        curryRightN: LodashCurryRightN;
        debounce: LodashDebounce;
        deburr: LodashDeburr;
        defaults: LodashDefaults;
        defaultsAll: LodashDefaultsAll;
        defaultsDeep: LodashDefaultsDeep;
        defaultsDeepAll: LodashDefaultsDeepAll;
        defaultTo: LodashDefaultTo;
        defer: LodashDefer;
        delay: LodashDelay;
        difference: LodashDifference;
        differenceBy: LodashDifferenceBy;
        differenceWith: LodashDifferenceWith;
        dissoc: LodashUnset;
        dissocPath: LodashUnset;
        divide: LodashDivide;
        drop: LodashDrop;
        dropLast: LodashDropRight;
        dropLastWhile: LodashDropRightWhile;
        dropRight: LodashDropRight;
        dropRightWhile: LodashDropRightWhile;
        dropWhile: LodashDropWhile;
        each: LodashForEach;
        eachRight: LodashForEachRight;
        endsWith: LodashEndsWith;
        entries: LodashToPairs;
        entriesIn: LodashToPairsIn;
        eq: LodashEq;
        equals: LodashIsEqual;
        escape: LodashEscape;
        escapeRegExp: LodashEscapeRegExp;
        every: LodashEvery;
        extend: LodashExtend;
        extendAll: LodashExtendAll;
        extendAllWith: LodashExtendAllWith;
        extendWith: LodashExtendWith;
        F: LodashStubFalse;
        fill: LodashFill;
        filter: LodashFilter;
        find: LodashFind;
        findFrom: LodashFindFrom;
        findIndex: LodashFindIndex;
        findIndexFrom: LodashFindIndexFrom;
        findKey: LodashFindKey;
        findLast: LodashFindLast;
        findLastFrom: LodashFindLastFrom;
        findLastIndex: LodashFindLastIndex;
        findLastIndexFrom: LodashFindLastIndexFrom;
        findLastKey: LodashFindLastKey;
        first: LodashHead;
        flatMap: LodashFlatMap;
        flatMapDeep: LodashFlatMapDeep;
        flatMapDepth: LodashFlatMapDepth;
        flatten: LodashFlatten;
        flattenDeep: LodashFlattenDeep;
        flattenDepth: LodashFlattenDepth;
        flip: LodashFlip;
        floor: LodashFloor;
        flow: LodashFlow;
        flowRight: LodashFlowRight;
        forEach: LodashForEach;
        forEachRight: LodashForEachRight;
        forIn: LodashForIn;
        forInRight: LodashForInRight;
        forOwn: LodashForOwn;
        forOwnRight: LodashForOwnRight;
        fromPairs: LodashFromPairs;
        functions: LodashFunctions;
        functionsIn: LodashFunctionsIn;
        get: LodashGet;
        getOr: LodashGetOr;
        groupBy: LodashGroupBy;
        gt: LodashGt;
        gte: LodashGte;
        has: LodashHas;
        hasIn: LodashHasIn;
        head: LodashHead;
        identical: LodashEq;
        identity: LodashIdentity;
        includes: LodashIncludes;
        includesFrom: LodashIncludesFrom;
        indexBy: LodashKeyBy;
        indexOf: LodashIndexOf;
        indexOfFrom: LodashIndexOfFrom;
        init: LodashInitial;
        initial: LodashInitial;
        inRange: LodashInRange;
        intersection: LodashIntersection;
        intersectionBy: LodashIntersectionBy;
        intersectionWith: LodashIntersectionWith;
        invert: LodashInvert;
        invertBy: LodashInvertBy;
        invertObj: LodashInvert;
        invoke: LodashInvoke;
        invokeArgs: LodashInvokeArgs;
        invokeArgsMap: LodashInvokeArgsMap;
        invokeMap: LodashInvokeMap;
        isArguments: LodashIsArguments;
        isArray: LodashIsArray;
        isArrayBuffer: LodashIsArrayBuffer;
        isArrayLike: LodashIsArrayLike;
        isArrayLikeObject: LodashIsArrayLikeObject;
        isBoolean: LodashIsBoolean;
        isBuffer: LodashIsBuffer;
        isDate: LodashIsDate;
        isElement: LodashIsElement;
        isEmpty: LodashIsEmpty;
        isEqual: LodashIsEqual;
        isEqualWith: LodashIsEqualWith;
        isError: LodashIsError;
        isFinite: LodashIsFinite;
        isFunction: LodashIsFunction;
        isInteger: LodashIsInteger;
        isLength: LodashIsLength;
        isMap: LodashIsMap;
        isMatch: LodashIsMatch;
        isMatchWith: LodashIsMatchWith;
        isNaN: LodashIsNaN;
        isNative: LodashIsNative;
        isNil: LodashIsNil;
        isNull: LodashIsNull;
        isNumber: LodashIsNumber;
        isObject: LodashIsObject;
        isObjectLike: LodashIsObjectLike;
        isPlainObject: LodashIsPlainObject;
        isRegExp: LodashIsRegExp;
        isSafeInteger: LodashIsSafeInteger;
        isSet: LodashIsSet;
        isString: LodashIsString;
        isSymbol: LodashIsSymbol;
        isTypedArray: LodashIsTypedArray;
        isUndefined: LodashIsUndefined;
        isWeakMap: LodashIsWeakMap;
        isWeakSet: LodashIsWeakSet;
        iteratee: LodashIteratee;
        join: LodashJoin;
        juxt: LodashOver;
        kebabCase: LodashKebabCase;
        keyBy: LodashKeyBy;
        keys: LodashKeys;
        keysIn: LodashKeysIn;
        last: LodashLast;
        lastIndexOf: LodashLastIndexOf;
        lastIndexOfFrom: LodashLastIndexOfFrom;
        lowerCase: LodashLowerCase;
        lowerFirst: LodashLowerFirst;
        lt: LodashLt;
        lte: LodashLte;
        map: LodashMap;
        mapKeys: LodashMapKeys;
        mapValues: LodashMapValues;
        matches: LodashIsMatch;
        matchesProperty: LodashMatchesProperty;
        max: LodashMax;
        maxBy: LodashMaxBy;
        mean: LodashMean;
        meanBy: LodashMeanBy;
        memoize: LodashMemoize;
        merge: LodashMerge;
        mergeAll: LodashMergeAll;
        mergeAllWith: LodashMergeAllWith;
        mergeWith: LodashMergeWith;
        method: LodashMethod;
        methodOf: LodashMethodOf;
        min: LodashMin;
        minBy: LodashMinBy;
        multiply: LodashMultiply;
        nAry: LodashAry;
        negate: LodashNegate;
        noConflict: LodashNoConflict;
        noop: LodashNoop;
        now: LodashNow;
        nth: LodashNth;
        nthArg: LodashNthArg;
        omit: LodashOmit;
        omitAll: LodashOmit;
        omitBy: LodashOmitBy;
        once: LodashOnce;
        orderBy: LodashOrderBy;
        over: LodashOver;
        overArgs: LodashOverArgs;
        overEvery: LodashOverEvery;
        overSome: LodashOverSome;
        pad: LodashPad;
        padChars: LodashPadChars;
        padCharsEnd: LodashPadCharsEnd;
        padCharsStart: LodashPadCharsStart;
        padEnd: LodashPadEnd;
        padStart: LodashPadStart;
        parseInt: LodashParseInt;
        partial: LodashPartial;
        partialRight: LodashPartialRight;
        partition: LodashPartition;
        path: LodashPath;
        pathEq: LodashMatchesProperty;
        pathOr: LodashPathOr;
        paths: LodashAt;
        pick: LodashPick;
        pickAll: LodashPick;
        pickBy: LodashPickBy;
        pipe: LodashFlow;
        pluck: LodashMap;
        prop: LodashProp;
        propEq: LodashMatchesProperty;
        property: LodashProperty;
        propertyOf: LodashPropertyOf;
        propOr: LodashPropOr;
        props: LodashAt;
        pull: LodashPull;
        pullAll: LodashPullAll;
        pullAllBy: LodashPullAllBy;
        pullAllWith: LodashPullAllWith;
        pullAt: LodashPullAt;
        random: LodashRandom;
        range: LodashRange;
        rangeRight: LodashRangeRight;
        rangeStep: LodashRangeStep;
        rangeStepRight: LodashRangeStepRight;
        rearg: LodashRearg;
        reduce: LodashReduce;
        reduceRight: LodashReduceRight;
        reject: LodashReject;
        remove: LodashRemove;
        repeat: LodashRepeat;
        replace: LodashReplace;
        rest: LodashRest;
        restFrom: LodashRestFrom;
        result: LodashResult;
        reverse: LodashReverse;
        round: LodashRound;
        runInContext: LodashRunInContext;
        sample: LodashSample;
        sampleSize: LodashSampleSize;
        set: LodashSet;
        setWith: LodashSetWith;
        shuffle: LodashShuffle;
        size: LodashSize;
        slice: LodashSlice;
        snakeCase: LodashSnakeCase;
        some: LodashSome;
        sortBy: LodashSortBy;
        sortedIndex: LodashSortedIndex;
        sortedIndexBy: LodashSortedIndexBy;
        sortedIndexOf: LodashSortedIndexOf;
        sortedLastIndex: LodashSortedLastIndex;
        sortedLastIndexBy: LodashSortedLastIndexBy;
        sortedLastIndexOf: LodashSortedLastIndexOf;
        sortedUniq: LodashSortedUniq;
        sortedUniqBy: LodashSortedUniqBy;
        split: LodashSplit;
        spread: LodashSpread;
        spreadFrom: LodashSpreadFrom;
        startCase: LodashStartCase;
        startsWith: LodashStartsWith;
        stubArray: LodashStubArray;
        stubFalse: LodashStubFalse;
        stubObject: LodashStubObject;
        stubString: LodashStubString;
        stubTrue: LodashStubTrue;
        subtract: LodashSubtract;
        sum: LodashSum;
        sumBy: LodashSumBy;
        symmetricDifference: LodashXor;
        symmetricDifferenceBy: LodashXorBy;
        symmetricDifferenceWith: LodashXorWith;
        T: LodashStubTrue;
        tail: LodashTail;
        take: LodashTake;
        takeLast: LodashTakeRight;
        takeLastWhile: LodashTakeRightWhile;
        takeRight: LodashTakeRight;
        takeRightWhile: LodashTakeRightWhile;
        takeWhile: LodashTakeWhile;
        tap: LodashTap;
        template: LodashTemplate;
        throttle: LodashThrottle;
        thru: LodashThru;
        times: LodashTimes;
        toArray: LodashToArray;
        toFinite: LodashToFinite;
        toInteger: LodashToInteger;
        toLength: LodashToLength;
        toLower: LodashToLower;
        toNumber: LodashToNumber;
        toPairs: LodashToPairs;
        toPairsIn: LodashToPairsIn;
        toPath: LodashToPath;
        toPlainObject: LodashToPlainObject;
        toSafeInteger: LodashToSafeInteger;
        toString: LodashToString;
        toUpper: LodashToUpper;
        transform: LodashTransform;
        trim: LodashTrim;
        trimChars: LodashTrimChars;
        trimCharsEnd: LodashTrimCharsEnd;
        trimCharsStart: LodashTrimCharsStart;
        trimEnd: LodashTrimEnd;
        trimStart: LodashTrimStart;
        truncate: LodashTruncate;
        unapply: LodashUnapply;
        unary: LodashUnary;
        unescape: LodashUnescape;
        union: LodashUnion;
        unionBy: LodashUnionBy;
        unionWith: LodashUnionWith;
        uniq: LodashUniq;
        uniqBy: LodashUniqBy;
        uniqueId: LodashUniqueId;
        uniqWith: LodashUniqWith;
        unnest: LodashFlatten;
        unset: LodashUnset;
        unzip: LodashUnzip;
        unzipWith: LodashUnzipWith;
        update: LodashUpdate;
        updateWith: LodashUpdateWith;
        upperCase: LodashUpperCase;
        upperFirst: LodashUpperFirst;
        useWith: LodashOverArgs;
        values: LodashValues;
        valuesIn: LodashValuesIn;
        where: LodashConformsTo;
        whereEq: LodashIsMatch;
        without: LodashWithout;
        words: LodashWords;
        wrap: LodashWrap;
        xor: LodashXor;
        xorBy: LodashXorBy;
        xorWith: LodashXorWith;
        zip: LodashZip;
        zipAll: LodashZipAll;
        zipObj: LodashZipObject;
        zipObject: LodashZipObject;
        zipObjectDeep: LodashZipObjectDeep;
        zipWith: LodashZipWith;
        __: lodash.__;
        placeholder: lodash.__;
    }
}
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isArrayLikeObject.d.ts ===
import { isArrayLikeObject } from "./index";
export = isArrayLikeObject;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isElement.d.ts ===
import { isElement } from "./index";
export = isElement;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/zipWith.d.ts ===
import { zipWith } from "./index";
export = zipWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isEqualWith.d.ts ===
import { isEqualWith } from "./index";
export = isEqualWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/mergeWith.d.ts ===
import { mergeWith } from "./index";
export = mergeWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/startsWith.d.ts ===
import { startsWith } from "./index";
export = startsWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/xor.d.ts ===
import { xor } from "./index";
export = xor;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/toPairsIn.d.ts ===
import { toPairsIn } from "./index";
export = toPairsIn;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/updateWith.d.ts ===
import { updateWith } from "./index";
export = updateWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/padStart.d.ts ===
import { padStart } from "./index";
export = padStart;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/negate.d.ts ===
import { negate } from "./index";
export = negate;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isNull.d.ts ===
import { isNull } from "./index";
export = isNull;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isWeakSet.d.ts ===
import { isWeakSet } from "./index";
export = isWeakSet;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/flatMapDeep.d.ts ===
import { flatMapDeep } from "./index";
export = flatMapDeep;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/defaults.d.ts ===
import { defaults } from "./index";
export = defaults;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/dropRight.d.ts ===
import { dropRight } from "./index";
export = dropRight;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/mapKeys.d.ts ===
import { mapKeys } from "./index";
export = mapKeys;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/unzipWith.d.ts ===
import { unzipWith } from "./index";
export = unzipWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/initial.d.ts ===
import { initial } from "./index";
export = initial;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/includes.d.ts ===
import { includes } from "./index";
export = includes;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/ceil.d.ts ===
import { ceil } from "./index";
export = ceil;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/lt.d.ts ===
import { lt } from "./index";
export = lt;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/index.d.ts ===
/// <reference path="./common/common.d.ts" />
/// <reference path="./common/array.d.ts" />
/// <reference path="./common/collection.d.ts" />
/// <reference path="./common/date.d.ts" />
/// <reference path="./common/function.d.ts" />
/// <reference path="./common/lang.d.ts" />
/// <reference path="./common/math.d.ts" />
/// <reference path="./common/number.d.ts" />
/// <reference path="./common/object.d.ts" />
/// <reference path="./common/seq.d.ts" />
/// <reference path="./common/string.d.ts" />
/// <reference path="./common/util.d.ts" />

export = _;
export as namespace _;

declare const _: _.LoDashStatic;
declare namespace _ {
    // eslint-disable-next-line @typescript-eslint/no-empty-interface -- (This will be augmented)
    interface LoDashStatic {}
}
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/sortBy.d.ts ===
import { sortBy } from "./index";
export = sortBy;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/partition.d.ts ===
import { partition } from "./index";
export = partition;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/reverse.d.ts ===
import { reverse } from "./index";
export = reverse;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/overSome.d.ts ===
import { overSome } from "./index";
export = overSome;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/tap.d.ts ===
import { tap } from "./index";
export = tap;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/throttle.d.ts ===
import { throttle } from "./index";
export = throttle;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/flatten.d.ts ===
import { flatten } from "./index";
export = flatten;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/chunk.d.ts ===
import { chunk } from "./index";
export = chunk;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/groupBy.d.ts ===
import { groupBy } from "./index";
export = groupBy;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/ary.d.ts ===
import { ary } from "./index";
export = ary;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/toNumber.d.ts ===
import { toNumber } from "./index";
export = toNumber;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/dropWhile.d.ts ===
import { dropWhile } from "./index";
export = dropWhile;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/assignWith.d.ts ===
import { assignWith } from "./index";
export = assignWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/toPlainObject.d.ts ===
import { toPlainObject } from "./index";
export = toPlainObject;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/min.d.ts ===
import { min } from "./index";
export = min;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/floor.d.ts ===
import { floor } from "./index";
export = floor;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/omit.d.ts ===
import { omit } from "./index";
export = omit;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isWeakMap.d.ts ===
import { isWeakMap } from "./index";
export = isWeakMap;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/times.d.ts ===
import { times } from "./index";
export = times;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/flatMap.d.ts ===
import { flatMap } from "./index";
export = flatMap;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/keysIn.d.ts ===
import { keysIn } from "./index";
export = keysIn;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/flattenDeep.d.ts ===
import { flattenDeep } from "./index";
export = flattenDeep;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/forOwn.d.ts ===
import { forOwn } from "./index";
export = forOwn;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/escapeRegExp.d.ts ===
import { escapeRegExp } from "./index";
export = escapeRegExp;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/transform.d.ts ===
import { transform } from "./index";
export = transform;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/findLastKey.d.ts ===
import { findLastKey } from "./index";
export = findLastKey;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/upperCase.d.ts ===
import { upperCase } from "./index";
export = upperCase;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/indexOf.d.ts ===
import { indexOf } from "./index";
export = indexOf;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/differenceWith.d.ts ===
import { differenceWith } from "./index";
export = differenceWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/fromPairs.d.ts ===
import { fromPairs } from "./index";
export = fromPairs;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/debounce.d.ts ===
import { debounce } from "./index";
export = debounce;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isInteger.d.ts ===
import { isInteger } from "./index";
export = isInteger;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/after.d.ts ===
import { after } from "./index";
export = after;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/sortedLastIndexOf.d.ts ===
import { sortedLastIndexOf } from "./index";
export = sortedLastIndexOf;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/pullAll.d.ts ===
import { pullAll } from "./index";
export = pullAll;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isEmpty.d.ts ===
import { isEmpty } from "./index";
export = isEmpty;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/multiply.d.ts ===
import { multiply } from './index';
export = multiply;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/cloneWith.d.ts ===
import { cloneWith } from "./index";
export = cloneWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/takeRight.d.ts ===
import { takeRight } from "./index";
export = takeRight;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/keyBy.d.ts ===
import { keyBy } from "./index";
export = keyBy;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isSymbol.d.ts ===
import { isSymbol } from "./index";
export = isSymbol;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/escape.d.ts ===
import { escape } from "./index";
export = escape;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/gte.d.ts ===
import { gte } from "./index";
export = gte;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/unescape.d.ts ===
import { unescape } from "./index";
export = unescape;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/xorWith.d.ts ===
import { xorWith } from "./index";
export = xorWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/set.d.ts ===
import { set } from "./index";
export = set;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/isNil.d.ts ===
import { isNil } from "./index";
export = isNil;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/mapValues.d.ts ===
import { mapValues } from "./index";
export = mapValues;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/countBy.d.ts ===
import { countBy } from "./index";
export = countBy;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/add.d.ts ===
import { add } from "./index";
export = add;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/sum.d.ts ===
import { sum } from "./index";
export = sum;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/stubTrue.d.ts ===
import { stubTrue } from "./index";
export = stubTrue;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/extendWith.d.ts ===
import { extendWith } from "./index";
export = extendWith;
=== END FILE ===
=== START FILE: ./node_modules/@types/lodash/nth.d.ts ===
import { nth } from "./index";
export = nth;
=== END FILE ===
=== START FILE: ./node_modules/@types/debug/index.d.ts ===
declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };

export = debug;
export as namespace debug;

declare namespace debug {
    interface Debug {
        (namespace: string): Debugger;
        coerce: (val: any) => any;
        disable: () => string;
        enable: (namespaces: string) => void;
        enabled: (namespaces: string) => boolean;
        formatArgs: (this: Debugger, args: any[]) => void;
        log: (...args: any[]) => any;
        selectColor: (namespace: string) => string | number;
        humanize: typeof import("ms");

        names: RegExp[];
        skips: RegExp[];

        formatters: Formatters;

        inspectOpts?: {
            hideDate?: boolean | number | null;
            colors?: boolean | number | null;
            depth?: boolean | number | null;
            showHidden?: boolean | number | null;
        };
    }

    type IDebug = Debug;

    interface Formatters {
        [formatter: string]: (v: any) => string;
    }

    type IDebugger = Debugger;

    interface Debugger {
        (formatter: any, ...args: any[]): void;

        color: string;
        diff: number;
        enabled: boolean;
        log: (...args: any[]) => any;
        namespace: string;
        destroy: () => boolean;
        extend: (namespace: string, delimiter?: string) => Debugger;
    }
}
=== END FILE ===
=== START FILE: ./node_modules/@types/json-schema/index.d.ts ===
// ==================================================================================================
// JSON Schema Draft 04
// ==================================================================================================

/**
 * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
 */
export type JSONSchema4TypeName =
    | "string" //
    | "number"
    | "integer"
    | "boolean"
    | "object"
    | "array"
    | "null"
    | "any";

/**
 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5
 */
export type JSONSchema4Type =
    | string //
    | number
    | boolean
    | JSONSchema4Object
    | JSONSchema4Array
    | null;

// Workaround for infinite type recursion
export interface JSONSchema4Object {
    [key: string]: JSONSchema4Type;
}

// Workaround for infinite type recursion
// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
export interface JSONSchema4Array extends Array<JSONSchema4Type> {}

/**
 * Meta schema
 *
 * Recommended values:
 * - 'http://json-schema.org/schema#'
 * - 'http://json-schema.org/hyper-schema#'
 * - 'http://json-schema.org/draft-04/schema#'
 * - 'http://json-schema.org/draft-04/hyper-schema#'
 * - 'http://json-schema.org/draft-03/schema#'
 * - 'http://json-schema.org/draft-03/hyper-schema#'
 *
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
 */
export type JSONSchema4Version = string;

/**
 * JSON Schema V4
 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04
 */
export interface JSONSchema4 {
    id?: string | undefined;
    $ref?: string | undefined;
    $schema?: JSONSchema4Version | undefined;

    /**
     * This attribute is a string that provides a short description of the
     * instance property.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21
     */
    title?: string | undefined;

    /**
     * This attribute is a string that provides a full description of the of
     * purpose the instance property.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22
     */
    description?: string | undefined;

    default?: JSONSchema4Type | undefined;
    multipleOf?: number | undefined;
    maximum?: number | undefined;
    exclusiveMaximum?: boolean | undefined;
    minimum?: number | undefined;
    exclusiveMinimum?: boolean | undefined;
    maxLength?: number | undefined;
    minLength?: number | undefined;
    pattern?: string | undefined;

    /**
     * May only be defined when "items" is defined, and is a tuple of JSONSchemas.
     *
     * This provides a definition for additional items in an array instance
     * when tuple definitions of the items is provided.  This can be false
     * to indicate additional items in the array are not allowed, or it can
     * be a schema that defines the schema of the additional items.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6
     */
    additionalItems?: boolean | JSONSchema4 | undefined;

    /**
     * This attribute defines the allowed items in an instance array, and
     * MUST be a schema or an array of schemas.  The default value is an
     * empty schema which allows any value for items in the instance array.
     *
     * When this attribute value is a schema and the instance value is an
     * array, then all the items in the array MUST be valid according to the
     * schema.
     *
     * When this attribute value is an array of schemas and the instance
     * value is an array, each position in the instance array MUST conform
     * to the schema in the corresponding position for this array.  This
     * called tuple typing.  When tuple typing is used, additional items are
     * allowed, disallowed, or constrained by the "additionalItems"
     * (Section 5.6) attribute using the same rules as
     * "additionalProperties" (Section 5.4) for objects.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5
     */
    items?: JSONSchema4 | JSONSchema4[] | undefined;

    maxItems?: number | undefined;
    minItems?: number | undefined;
    uniqueItems?: boolean | undefined;
    maxProperties?: number | undefined;
    minProperties?: number | undefined;

    /**
     * This attribute indicates if the instance must have a value, and not
     * be undefined. This is false by default, making the instance
     * optional.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7
     */
    required?: boolean | string[] | undefined;

    /**
     * This attribute defines a schema for all properties that are not
     * explicitly defined in an object type definition. If specified, the
     * value MUST be a schema or a boolean. If false is provided, no
     * additional properties are allowed beyond the properties defined in
     * the schema. The default value is an empty schema which allows any
     * value for additional properties.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4
     */
    additionalProperties?: boolean | JSONSchema4 | undefined;

    definitions?: {
        [k: string]: JSONSchema4;
    } | undefined;

    /**
     * This attribute is an object with property definitions that define the
     * valid values of instance object property values. When the instance
     * value is an object, the property values of the instance object MUST
     * conform to the property definitions in this object. In this object,
     * each property definition's value MUST be a schema, and the property's
     * name MUST be the name of the instance property that it defines.  The
     * instance property value MUST be valid according to the schema from
     * the property definition. Properties are considered unordered, the
     * order of the instance properties MAY be in any order.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2
     */
    properties?: {
        [k: string]: JSONSchema4;
    } | undefined;

    /**
     * This attribute is an object that defines the schema for a set of
     * property names of an object instance. The name of each property of
     * this attribute's object is a regular expression pattern in the ECMA
     * 262/Perl 5 format, while the value is a schema. If the pattern
     * matches the name of a property on the instance object, the value of
     * the instance's property MUST be valid against the pattern name's
     * schema value.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3
     */
    patternProperties?: {
        [k: string]: JSONSchema4;
    } | undefined;
    dependencies?: {
        [k: string]: JSONSchema4 | string[];
    } | undefined;

    /**
     * This provides an enumeration of all possible values that are valid
     * for the instance property. This MUST be an array, and each item in
     * the array represents a possible value for the instance value. If
     * this attribute is defined, the instance value MUST be one of the
     * values in the array in order for the schema to be valid.
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19
     */
    enum?: JSONSchema4Type[] | undefined;

    /**
     * A single type, or a union of simple types
     */
    type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined;

    allOf?: JSONSchema4[] | undefined;
    anyOf?: JSONSchema4[] | undefined;
    oneOf?: JSONSchema4[] | undefined;
    not?: JSONSchema4 | undefined;

    /**
     * The value of this property MUST be another schema which will provide
     * a base schema which the current schema will inherit from.  The
     * inheritance rules are such that any instance that is valid according
     * to the current schema MUST be valid according to the referenced
     * schema.  This MAY also be an array, in which case, the instance MUST
     * be valid for all the schemas in the array.  A schema that extends
     * another schema MAY define additional attributes, constrain existing
     * attributes, or add other constraints.
     *
     * Conceptually, the behavior of extends can be seen as validating an
     * instance against all constraints in the extending schema as well as
     * the extended schema(s).
     *
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26
     */
    extends?: string | string[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6
     */
    [k: string]: any;

    format?: string | undefined;
}

// ==================================================================================================
// JSON Schema Draft 06
// ==================================================================================================

export type JSONSchema6TypeName =
    | "string" //
    | "number"
    | "integer"
    | "boolean"
    | "object"
    | "array"
    | "null"
    | "any";

export type JSONSchema6Type =
    | string //
    | number
    | boolean
    | JSONSchema6Object
    | JSONSchema6Array
    | null;

// Workaround for infinite type recursion
export interface JSONSchema6Object {
    [key: string]: JSONSchema6Type;
}

// Workaround for infinite type recursion
// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
export interface JSONSchema6Array extends Array<JSONSchema6Type> {}

/**
 * Meta schema
 *
 * Recommended values:
 * - 'http://json-schema.org/schema#'
 * - 'http://json-schema.org/hyper-schema#'
 * - 'http://json-schema.org/draft-06/schema#'
 * - 'http://json-schema.org/draft-06/hyper-schema#'
 *
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
 */
export type JSONSchema6Version = string;

/**
 * JSON Schema V6
 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01
 */
export type JSONSchema6Definition = JSONSchema6 | boolean;
export interface JSONSchema6 {
    $id?: string | undefined;
    $ref?: string | undefined;
    $schema?: JSONSchema6Version | undefined;

    /**
     * Must be strictly greater than 0.
     * A numeric instance is valid only if division by this keyword's value results in an integer.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
     */
    multipleOf?: number | undefined;

    /**
     * Representing an inclusive upper limit for a numeric instance.
     * This keyword validates only if the instance is less than or exactly equal to "maximum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
     */
    maximum?: number | undefined;

    /**
     * Representing an exclusive upper limit for a numeric instance.
     * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
     */
    exclusiveMaximum?: number | undefined;

    /**
     * Representing an inclusive lower limit for a numeric instance.
     * This keyword validates only if the instance is greater than or exactly equal to "minimum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
     */
    minimum?: number | undefined;

    /**
     * Representing an exclusive lower limit for a numeric instance.
     * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
     */
    exclusiveMinimum?: number | undefined;

    /**
     * Must be a non-negative integer.
     * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
     */
    maxLength?: number | undefined;

    /**
     * Must be a non-negative integer.
     * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
     * Omitting this keyword has the same behavior as a value of 0.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
     */
    minLength?: number | undefined;

    /**
     * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
     */
    pattern?: string | undefined;

    /**
     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
     * Omitting this keyword has the same behavior as an empty schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
     */
    items?: JSONSchema6Definition | JSONSchema6Definition[] | undefined;

    /**
     * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
     * If "items" is an array of schemas, validation succeeds if every instance element
     * at a position greater than the size of "items" validates against "additionalItems".
     * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
     * (possibly the default value of an empty schema) is applied to all elements.
     * Omitting this keyword has the same behavior as an empty schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
     */
    additionalItems?: JSONSchema6Definition | undefined;

    /**
     * Must be a non-negative integer.
     * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
     */
    maxItems?: number | undefined;

    /**
     * Must be a non-negative integer.
     * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
     * Omitting this keyword has the same behavior as a value of 0.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
     */
    minItems?: number | undefined;

    /**
     * If this keyword has boolean value false, the instance validates successfully.
     * If it has boolean value true, the instance validates successfully if all of its elements are unique.
     * Omitting this keyword has the same behavior as a value of false.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
     */
    uniqueItems?: boolean | undefined;

    /**
     * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
     */
    contains?: JSONSchema6Definition | undefined;

    /**
     * Must be a non-negative integer.
     * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
     */
    maxProperties?: number | undefined;

    /**
     * Must be a non-negative integer.
     * An object instance is valid against "maxProperties" if its number of properties is greater than,
     * or equal to, the value of this keyword.
     * Omitting this keyword has the same behavior as a value of 0.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
     */
    minProperties?: number | undefined;

    /**
     * Elements of this array must be unique.
     * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
     * Omitting this keyword has the same behavior as an empty array.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
     */
    required?: string[] | undefined;

    /**
     * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
     * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
     * the child instance for that name successfully validates against the corresponding schema.
     * Omitting this keyword has the same behavior as an empty object.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
     */
    properties?: {
        [k: string]: JSONSchema6Definition;
    } | undefined;

    /**
     * This attribute is an object that defines the schema for a set of property names of an object instance.
     * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
     * If the pattern matches the name of a property on the instance object, the value of the instance's property
     * MUST be valid against the pattern name's schema value.
     * Omitting this keyword has the same behavior as an empty object.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
     */
    patternProperties?: {
        [k: string]: JSONSchema6Definition;
    } | undefined;

    /**
     * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
     * If specified, the value MUST be a schema or a boolean.
     * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
     * The default value is an empty schema which allows any value for additional properties.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
     */
    additionalProperties?: JSONSchema6Definition | undefined;

    /**
     * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
     * Each property specifies a dependency.
     * If the dependency value is an array, each element in the array must be unique.
     * Omitting this keyword has the same behavior as an empty object.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
     */
    dependencies?: {
        [k: string]: JSONSchema6Definition | string[];
    } | undefined;

    /**
     * Takes a schema which validates the names of all properties rather than their values.
     * Note the property name that the schema is testing will always be a string.
     * Omitting this keyword has the same behavior as an empty schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
     */
    propertyNames?: JSONSchema6Definition | undefined;

    /**
     * This provides an enumeration of all possible values that are valid
     * for the instance property. This MUST be an array, and each item in
     * the array represents a possible value for the instance value. If
     * this attribute is defined, the instance value MUST be one of the
     * values in the array in order for the schema to be valid.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23
     */
    enum?: JSONSchema6Type[] | undefined;

    /**
     * More readable form of a one-element "enum"
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
     */
    const?: JSONSchema6Type | undefined;

    /**
     * A single type, or a union of simple types
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
     */
    type?: JSONSchema6TypeName | JSONSchema6TypeName[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
     */
    allOf?: JSONSchema6Definition[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
     */
    anyOf?: JSONSchema6Definition[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
     */
    oneOf?: JSONSchema6Definition[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
     */
    not?: JSONSchema6Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
     */
    definitions?: {
        [k: string]: JSONSchema6Definition;
    } | undefined;

    /**
     * This attribute is a string that provides a short description of the instance property.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
     */
    title?: string | undefined;

    /**
     * This attribute is a string that provides a full description of the of purpose the instance property.
     *
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
     */
    description?: string | undefined;

    /**
     * This keyword can be used to supply a default JSON value associated with a particular schema.
     * It is RECOMMENDED that a default value be valid against the associated schema.
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
     */
    default?: JSONSchema6Type | undefined;

    /**
     * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
     */
    examples?: JSONSchema6Type[] | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
     */
    format?: string | undefined;
}

// ==================================================================================================
// JSON Schema Draft 07
// ==================================================================================================
// https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
// --------------------------------------------------------------------------------------------------

/**
 * Primitive type
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
 */
export type JSONSchema7TypeName =
    | "string" //
    | "number"
    | "integer"
    | "boolean"
    | "object"
    | "array"
    | "null";

/**
 * Primitive type
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1
 */
export type JSONSchema7Type =
    | string //
    | number
    | boolean
    | JSONSchema7Object
    | JSONSchema7Array
    | null;

// Workaround for infinite type recursion
export interface JSONSchema7Object {
    [key: string]: JSONSchema7Type;
}

// Workaround for infinite type recursion
// https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540
export interface JSONSchema7Array extends Array<JSONSchema7Type> {}

/**
 * Meta schema
 *
 * Recommended values:
 * - 'http://json-schema.org/schema#'
 * - 'http://json-schema.org/hyper-schema#'
 * - 'http://json-schema.org/draft-07/schema#'
 * - 'http://json-schema.org/draft-07/hyper-schema#'
 *
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
 */
export type JSONSchema7Version = string;

/**
 * JSON Schema v7
 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01
 */
export type JSONSchema7Definition = JSONSchema7 | boolean;
export interface JSONSchema7 {
    $id?: string | undefined;
    $ref?: string | undefined;
    $schema?: JSONSchema7Version | undefined;
    $comment?: string | undefined;

    /**
     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4
     * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A
     */
    $defs?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1
     */
    type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined;
    enum?: JSONSchema7Type[] | undefined;
    const?: JSONSchema7Type | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2
     */
    multipleOf?: number | undefined;
    maximum?: number | undefined;
    exclusiveMaximum?: number | undefined;
    minimum?: number | undefined;
    exclusiveMinimum?: number | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3
     */
    maxLength?: number | undefined;
    minLength?: number | undefined;
    pattern?: string | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4
     */
    items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined;
    additionalItems?: JSONSchema7Definition | undefined;
    maxItems?: number | undefined;
    minItems?: number | undefined;
    uniqueItems?: boolean | undefined;
    contains?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5
     */
    maxProperties?: number | undefined;
    minProperties?: number | undefined;
    required?: string[] | undefined;
    properties?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;
    patternProperties?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;
    additionalProperties?: JSONSchema7Definition | undefined;
    dependencies?: {
        [key: string]: JSONSchema7Definition | string[];
    } | undefined;
    propertyNames?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6
     */
    if?: JSONSchema7Definition | undefined;
    then?: JSONSchema7Definition | undefined;
    else?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7
     */
    allOf?: JSONSchema7Definition[] | undefined;
    anyOf?: JSONSchema7Definition[] | undefined;
    oneOf?: JSONSchema7Definition[] | undefined;
    not?: JSONSchema7Definition | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7
     */
    format?: string | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8
     */
    contentMediaType?: string | undefined;
    contentEncoding?: string | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9
     */
    definitions?: {
        [key: string]: JSONSchema7Definition;
    } | undefined;

    /**
     * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
     */
    title?: string | undefined;
    description?: string | undefined;
    default?: JSONSchema7Type | undefined;
    readOnly?: boolean | undefined;
    writeOnly?: boolean | undefined;
    examples?: JSONSchema7Type | undefined;
}

export interface ValidationResult {
    valid: boolean;
    errors: ValidationError[];
}

export interface ValidationError {
    property: string;
    message: string;
}

/**
 * To use the validator call JSONSchema.validate with an instance object and an optional schema object.
 * If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating),
 * that schema will be used to validate and the schema parameter is not necessary (if both exist,
 * both validations will occur).
 */
export function validate(instance: {}, schema: JSONSchema4 | JSONSchema6 | JSONSchema7): ValidationResult;

/**
 * The checkPropertyChange method will check to see if an value can legally be in property with the given schema
 * This is slightly different than the validate method in that it will fail if the schema is readonly and it will
 * not check for self-validation, it is assumed that the passed in value is already internally valid.
 */
export function checkPropertyChange(
    value: any,
    schema: JSONSchema4 | JSONSchema6 | JSONSchema7,
    property: string,
): ValidationResult;

/**
 * This checks to ensure that the result is valid and will throw an appropriate error message if it is not.
 */
export function mustBeValid(result: ValidationResult): void;
=== END FILE ===
=== START FILE: ./node_modules/@types/use-sync-external-store/with-selector.d.ts ===
export function useSyncExternalStoreWithSelector<Snapshot, Selection>(
    subscribe: (onStoreChange: () => void) => () => void,
    getSnapshot: () => Snapshot,
    getServerSnapshot: undefined | null | (() => Snapshot),
    selector: (snapshot: Snapshot) => Selection,
    isEqual?: (a: Selection, b: Selection) => boolean,
): Selection;
=== END FILE ===
=== START FILE: ./node_modules/@types/use-sync-external-store/shim/with-selector.d.ts ===
export * from "../with-selector";
=== END FILE ===
=== START FILE: ./node_modules/@types/use-sync-external-store/shim/index.d.ts ===
export * from "../";
=== END FILE ===
=== START FILE: ./node_modules/@types/use-sync-external-store/index.d.ts ===
export function useSyncExternalStore<Snapshot>(
    subscribe: (onStoreChange: () => void) => () => void,
    getSnapshot: () => Snapshot,
    getServerSnapshot?: () => Snapshot,
): Snapshot;
=== END FILE ===
=== START FILE: ./node_modules/@types/mapbox__vector-tile/index.d.ts ===
import Pbf = require("pbf");
import { Feature } from "geojson";
import Point = require("@mapbox/point-geometry");

export class VectorTile {
    constructor(pbf: Pbf);
    layers: { [_: string]: VectorTileLayer };
}

export class VectorTileFeature {
    static types: ["Unknown", "Point", "LineString", "Polygon"];
    extent: number;
    type: 0 | 1 | 2 | 3;
    id: number;
    properties: { [_: string]: string | number | boolean };
    loadGeometry(): Point[][];
    toGeoJSON(x: number, y: number, z: number): Feature;
    bbox?(): [number, number, number, number];
}

export class VectorTileLayer {
    constructor(pbf: Pbf);
    version?: number;
    name: string;
    extent: number;
    length: number;
    feature(featureIndex: number): VectorTileFeature;
}
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/outside.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return true if the version is outside the bounds of the range in either the high or low direction.
 * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.)
 */
declare function outside(
    version: string | SemVer,
    range: string | Range,
    hilo: ">" | "<",
    optionsOrLoose?: boolean | semver.RangeOptions,
): boolean;
export = outside;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/intersects.d.ts ===
import Range = require("../classes/range");
import semver = require("../index");

/**
 * Return true if any of the ranges comparators intersect
 */
declare function intersects(
    range1: string | Range,
    range2: string | Range,
    optionsOrLoose?: boolean | semver.RangeOptions,
): boolean;

export = intersects;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/ltr.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return true if version is less than all the versions possible in the range.
 */
declare function ltr(
    version: string | SemVer,
    range: string | Range,
    optionsOrLoose?: boolean | semver.RangeOptions,
): boolean;

export = ltr;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/min-version.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the lowest version that can possibly match the given range.
 */
declare function minVersion(range: string | Range, optionsOrLoose?: boolean | semver.Options): SemVer | null;

export = minVersion;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/max-satisfying.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the highest version in the list that satisfies the range, or null if none of them do.
 */
declare function maxSatisfying<T extends string | SemVer>(
    versions: readonly T[],
    range: string | Range,
    optionsOrLoose?: boolean | semver.RangeOptions,
): T | null;

export = maxSatisfying;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/gtr.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return true if version is greater than all the versions possible in the range.
 */
declare function gtr(
    version: string | SemVer,
    range: string | Range,
    optionsOrLoose?: boolean | semver.RangeOptions,
): boolean;

export = gtr;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/to-comparators.d.ts ===
import Range = require("../classes/range");
import semver = require("../index");

/**
 * Mostly just for testing and legacy API reasons
 */
declare function toComparators(range: string | Range, optionsOrLoose?: boolean | semver.Options): string[][];

export = toComparators;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/valid.d.ts ===
import Range = require("../classes/range");
import semver = require("../index");

/**
 * Return the valid range or null if it's not valid
 */
declare function validRange(
    range: string | Range | null | undefined,
    optionsOrLoose?: boolean | semver.RangeOptions,
): string | null;

export = validRange;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/min-satisfying.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the lowest version in the list that satisfies the range, or null if none of them do.
 */
declare function minSatisfying<T extends string | SemVer>(
    versions: readonly T[],
    range: string | Range,
    optionsOrLoose?: boolean | semver.RangeOptions,
): T | null;

export = minSatisfying;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/subset.d.ts ===
import Range = require("../classes/range");
import semver = require("../index");

/**
 * Return true if the subRange range is entirely contained by the superRange range.
 */
declare function subset(sub: string | Range, dom: string | Range, options?: semver.RangeOptions): boolean;

export = subset;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/ranges/simplify.d.ts ===
import Range = require("../classes/range");
import semver = require("../index");

/**
 * Return a "simplified" range that matches the same items in `versions` list as the range specified.
 * Note that it does *not* guarantee that it would match the same versions in all cases,
 * only for the set of versions provided.
 * This is useful when generating ranges by joining together multiple versions with `||` programmatically,
 * to provide the user with something a bit more ergonomic.
 * If the provided range is shorter in string-length than the generated range, then that is returned.
 */
declare function simplify(ranges: string[], range: string | Range, options?: semver.Options): string | Range;

export = simplify;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/compare.d.ts ===
import semver = require("../index");
import SemVer = require("../classes/semver");

/**
 * Compares two versions excluding build identifiers (the bit after `+` in the semantic version string).
 *
 * Sorts in ascending order when passed to `Array.sort()`.
 *
 * @return
 * - `0` if `v1` == `v2`
 * - `1` if `v1` is greater
 * - `-1` if `v2` is greater.
 */
declare function compare(
    v1: string | SemVer,
    v2: string | SemVer,
    optionsOrLoose?: boolean | semver.Options,
): 1 | 0 | -1;

export = compare;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/parse.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the parsed version as a SemVer object, or null if it's not valid.
 */
declare function parse(
    version: string | SemVer | null | undefined,
    optionsOrLoose?: boolean | semver.Options,
): SemVer | null;

export = parse;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/eq.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * v1 == v2 This is true if they're logically equivalent, even if they're not the exact same string. You already know how to compare strings.
 */
declare function eq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;

export = eq;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/major.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the major version number.
 */
declare function major(version: string | SemVer, optionsOrLoose?: boolean | semver.Options): number;

export = major;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/inc.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

declare namespace inc {
    /** Base number to be used for the prerelease identifier */
    type IdentifierBase = "0" | "1";
}

/**
 * Return the version incremented by the release type (major, premajor, minor, preminor, patch, prepatch, or prerelease), or null if it's not valid.
 */
declare function inc(
    version: string | SemVer,
    release: semver.ReleaseType,
    optionsOrLoose?: boolean | semver.Options,
    identifier?: string,
): string | null;
declare function inc(
    version: string | SemVer,
    release: semver.ReleaseType,
    identifier?: string,
    identifierBase?: inc.IdentifierBase | false,
): string | null;

export = inc;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/neq.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * v1 != v2 The opposite of eq.
 */
declare function neq(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;

export = neq;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/clean.d.ts ===
import semver = require("../index");

/**
 * Returns cleaned (removed leading/trailing whitespace, remove '=v' prefix) and parsed version, or null if version is invalid.
 */
declare function clean(version: string, optionsOrLoose?: boolean | semver.Options): string | null;

export = clean;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/compare-loose.d.ts ===
import SemVer = require("../classes/semver");

declare function compareLoose(v1: string | SemVer, v2: string | SemVer): 1 | 0 | -1;

export = compareLoose;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/compare-build.d.ts ===
import semver = require("../index");
import SemVer = require("../classes/semver");

/**
 * Compares two versions including build identifiers (the bit after `+` in the semantic version string).
 *
 * Sorts in ascending order when passed to `Array.sort()`.
 *
 * @return
 * - `0` if `v1` == `v2`
 * - `1` if `v1` is greater
 * - `-1` if `v2` is greater.
 *
 * @since 6.1.0
 */
declare function compareBuild(
    a: string | SemVer,
    b: string | SemVer,
    optionsOrLoose?: boolean | semver.Options,
): 1 | 0 | -1;
export = compareBuild;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/patch.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the patch version number.
 */
declare function patch(version: string | SemVer, optionsOrLoose?: boolean | semver.Options): number;

export = patch;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/lte.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * v1 <= v2
 */
declare function lte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;
export = lte;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/minor.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return the minor version number.
 */
declare function minor(version: string | SemVer, optionsOrLoose?: boolean | semver.Options): number;

export = minor;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/diff.d.ts ===
import semver = require("../index");
import SemVer = require("../classes/semver");

/**
 * Returns difference between two versions by the release type (major, premajor, minor, preminor, patch, prepatch, or prerelease), or null if the versions are the same.
 */
declare function diff(v1: string | SemVer, v2: string | SemVer): semver.ReleaseType | null;

export = diff;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/rcompare.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * The reverse of compare.
 *
 * Sorts in descending order when passed to `Array.sort()`.
 */
declare function rcompare(
    v1: string | SemVer,
    v2: string | SemVer,
    optionsOrLoose?: boolean | semver.Options,
): 1 | 0 | -1;

export = rcompare;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/sort.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Sorts an array of semver entries in ascending order using `compareBuild()`.
 */
declare function sort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | semver.Options): T[];

export = sort;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/coerce.d.ts ===
import semver = require("../index");
import SemVer = require("../classes/semver");

/**
 * Coerces a string to SemVer if possible
 */
declare function coerce(
    version: string | number | SemVer | null | undefined,
    options?: semver.CoerceOptions,
): SemVer | null;

export = coerce;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/gt.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * v1 > v2
 */
declare function gt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;

export = gt;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/prerelease.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Returns an array of prerelease components, or null if none exist.
 */
declare function prerelease(
    version: string | SemVer,
    optionsOrLoose?: boolean | semver.Options,
): ReadonlyArray<string | number> | null;

export = prerelease;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/valid.d.ts ===
import semver = require("../index");
import SemVer = require("../classes/semver");
/**
 * Return the parsed version as a string, or null if it's not valid.
 */
declare function valid(
    version: string | SemVer | null | undefined,
    optionsOrLoose?: boolean | semver.Options,
): string | null;

export = valid;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/cmp.d.ts ===
import semver = require("../index");
import SemVer = require("../classes/semver");

/**
 * Pass in a comparison string, and it'll call the corresponding semver comparison function.
 * "===" and "!==" do simple string comparison, but are included for completeness.
 * Throws if an invalid comparison string is provided.
 */
declare function cmp(
    v1: string | SemVer,
    operator: semver.Operator,
    v2: string | SemVer,
    optionsOrLoose?: boolean | semver.Options,
): boolean;

export = cmp;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/rsort.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Sorts an array of semver entries in descending order using `compareBuild()`.
 */
declare function rsort<T extends string | SemVer>(list: T[], optionsOrLoose?: boolean | semver.Options): T[];

export = rsort;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/lt.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * v1 < v2
 */
declare function lt(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;

export = lt;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/gte.d.ts ===
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * v1 >= v2
 */
declare function gte(v1: string | SemVer, v2: string | SemVer, optionsOrLoose?: boolean | semver.Options): boolean;

export = gte;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/functions/satisfies.d.ts ===
import Range = require("../classes/range");
import SemVer = require("../classes/semver");
import semver = require("../index");

/**
 * Return true if the version satisfies the range.
 */
declare function satisfies(
    version: string | SemVer,
    range: string | Range,
    optionsOrLoose?: boolean | semver.RangeOptions,
): boolean;

export = satisfies;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/preload.d.ts ===
import semver = require(".");
export = semver;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/classes/semver.d.ts ===
import semver = require("../index");

declare class SemVer {
    constructor(version: string | SemVer, optionsOrLoose?: boolean | semver.RangeOptions);

    raw: string;
    loose: boolean;
    options: semver.Options;
    format(): string;
    inspect(): string;

    major: number;
    minor: number;
    patch: number;
    version: string;
    build: readonly string[];
    prerelease: ReadonlyArray<string | number>;

    /**
     * Compares two versions excluding build identifiers (the bit after `+` in the semantic version string).
     *
     * @return
     * - `0` if `this` == `other`
     * - `1` if `this` is greater
     * - `-1` if `other` is greater.
     */
    compare(other: string | SemVer): 1 | 0 | -1;

    /**
     * Compares the release portion of two versions.
     *
     * @return
     * - `0` if `this` == `other`
     * - `1` if `this` is greater
     * - `-1` if `other` is greater.
     */
    compareMain(other: string | SemVer): 1 | 0 | -1;

    /**
     * Compares the prerelease portion of two versions.
     *
     * @return
     * - `0` if `this` == `other`
     * - `1` if `this` is greater
     * - `-1` if `other` is greater.
     */
    comparePre(other: string | SemVer): 1 | 0 | -1;

    /**
     * Compares the build identifier of two versions.
     *
     * @return
     * - `0` if `this` == `other`
     * - `1` if `this` is greater
     * - `-1` if `other` is greater.
     */
    compareBuild(other: string | SemVer): 1 | 0 | -1;

    inc(release: semver.ReleaseType, identifier?: string): SemVer;

    toString(): string;
}

export = SemVer;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/classes/comparator.d.ts ===
import semver = require("../index");
import SemVer = require("./semver");

declare class Comparator {
    constructor(comp: string | Comparator, optionsOrLoose?: boolean | semver.Options);

    semver: SemVer;
    operator: "" | "=" | "<" | ">" | "<=" | ">=";
    value: string;
    loose: boolean;
    options: semver.Options;
    parse(comp: string): void;
    test(version: string | SemVer): boolean;
    intersects(comp: Comparator, optionsOrLoose?: boolean | semver.Options): boolean;
}

export = Comparator;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/classes/range.d.ts ===
import semver = require("../index");
import Comparator = require("./comparator");
import SemVer = require("./semver");

declare class Range {
    constructor(range: string | Range, optionsOrLoose?: boolean | semver.RangeOptions);

    range: string;
    raw: string;
    loose: boolean;
    options: semver.Options;
    includePrerelease: boolean;
    format(): string;
    inspect(): string;

    set: ReadonlyArray<readonly Comparator[]>;
    parseRange(range: string): readonly Comparator[];
    test(version: string | SemVer): boolean;
    intersects(range: Range, optionsOrLoose?: boolean | semver.Options): boolean;
}
export = Range;
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/index.d.ts ===
// re-exports for index file

// functions for working with versions
import semverParse = require("./functions/parse");
import semverValid = require("./functions/valid");
import semverClean = require("./functions/clean");
import semverInc = require("./functions/inc");
import semverDiff = require("./functions/diff");
import semverMajor = require("./functions/major");
import semverMinor = require("./functions/minor");
import semverPatch = require("./functions/patch");
import semverPrerelease = require("./functions/prerelease");
import semverCompare = require("./functions/compare");
import semverRcompare = require("./functions/rcompare");
import semverCompareLoose = require("./functions/compare-loose");
import semverCompareBuild = require("./functions/compare-build");
import semverSort = require("./functions/sort");
import semverRsort = require("./functions/rsort");

export {
    semverClean as clean,
    semverCompare as compare,
    semverCompareBuild as compareBuild,
    semverCompareLoose as compareLoose,
    semverDiff as diff,
    semverInc as inc,
    semverMajor as major,
    semverMinor as minor,
    semverParse as parse,
    semverPatch as patch,
    semverPrerelease as prerelease,
    semverRcompare as rcompare,
    semverRsort as rsort,
    semverSort as sort,
    semverValid as valid,
};

// low-level comparators between versions
import semverGt = require("./functions/gt");
import semverLt = require("./functions/lt");
import semverEq = require("./functions/eq");
import semverNeq = require("./functions/neq");
import semverGte = require("./functions/gte");
import semverLte = require("./functions/lte");
import semverCmp = require("./functions/cmp");
import semverCoerce = require("./functions/coerce");

export {
    semverCmp as cmp,
    semverCoerce as coerce,
    semverEq as eq,
    semverGt as gt,
    semverGte as gte,
    semverLt as lt,
    semverLte as lte,
    semverNeq as neq,
};

// working with ranges
import semverSatisfies = require("./functions/satisfies");
import semverMaxSatisfying = require("./ranges/max-satisfying");
import semverMinSatisfying = require("./ranges/min-satisfying");
import semverToComparators = require("./ranges/to-comparators");
import semverMinVersion = require("./ranges/min-version");
import semverValidRange = require("./ranges/valid");
import semverOutside = require("./ranges/outside");
import semverGtr = require("./ranges/gtr");
import semverLtr = require("./ranges/ltr");
import semverIntersects = require("./ranges/intersects");
import simplify = require("./ranges/simplify");
import rangeSubset = require("./ranges/subset");

export {
    rangeSubset as subset,
    semverGtr as gtr,
    semverIntersects as intersects,
    semverLtr as ltr,
    semverMaxSatisfying as maxSatisfying,
    semverMinSatisfying as minSatisfying,
    semverMinVersion as minVersion,
    semverOutside as outside,
    semverSatisfies as satisfies,
    semverToComparators as toComparators,
    semverValidRange as validRange,
    simplify as simplifyRange,
};

// classes
import SemVer = require("./classes/semver");
import Range = require("./classes/range");
import Comparator = require("./classes/comparator");

export { Comparator, Range, SemVer };

// internals
import identifiers = require("./internals/identifiers");
export import compareIdentifiers = identifiers.compareIdentifiers;
export import rcompareIdentifiers = identifiers.rcompareIdentifiers;

export const SEMVER_SPEC_VERSION: "2.0.0";

export const RELEASE_TYPES: ReleaseType[];

export type ReleaseType = "major" | "premajor" | "minor" | "preminor" | "patch" | "prepatch" | "prerelease";

export interface Options {
    loose?: boolean | undefined;
}

export interface RangeOptions extends Options {
    includePrerelease?: boolean | undefined;
}
export interface CoerceOptions extends Options {
    includePrerelease?: boolean | undefined;
    /**
     * Used by `coerce()` to coerce from right to left.
     *
     * @default false
     *
     * @example
     * coerce('1.2.3.4', { rtl: true });
     * // => SemVer { version: '2.3.4', ... }
     *
     * @since 6.2.0
     */
    rtl?: boolean | undefined;
}

export type Operator = "===" | "!==" | "" | "=" | "==" | "!=" | ">" | ">=" | "<" | "<=";
=== END FILE ===
=== START FILE: ./node_modules/@types/semver/internals/identifiers.d.ts ===
/**
 * Compares two identifiers, must be numeric strings or truthy/falsy values.
 *
 * Sorts in ascending order when passed to `Array.sort()`.
 */
export function compareIdentifiers(a: string | null | undefined, b: string | null | undefined): 1 | 0 | -1;

/**
 * The reverse of compareIdentifiers.
 *
 * Sorts in descending order when passed to `Array.sort()`.
 */
export function rcompareIdentifiers(a: string | null | undefined, b: string | null | undefined): 1 | 0 | -1;
=== END FILE ===
=== START FILE: ./node_modules/@types/estree/flow.d.ts ===
declare namespace ESTree {
    interface FlowTypeAnnotation extends Node {}

    interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}

    interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}

    interface FlowDeclaration extends Declaration {}

    interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface ArrayTypeAnnotation extends FlowTypeAnnotation {
        elementType: FlowTypeAnnotation;
    }

    interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}

    interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface ClassImplements extends Node {
        id: Identifier;
        typeParameters?: TypeParameterInstantiation | null;
    }

    interface ClassProperty {
        key: Expression;
        value?: Expression | null;
        typeAnnotation?: TypeAnnotation | null;
        computed: boolean;
        static: boolean;
    }

    interface DeclareClass extends FlowDeclaration {
        id: Identifier;
        typeParameters?: TypeParameterDeclaration | null;
        body: ObjectTypeAnnotation;
        extends: InterfaceExtends[];
    }

    interface DeclareFunction extends FlowDeclaration {
        id: Identifier;
    }

    interface DeclareModule extends FlowDeclaration {
        id: Literal | Identifier;
        body: BlockStatement;
    }

    interface DeclareVariable extends FlowDeclaration {
        id: Identifier;
    }

    interface FunctionTypeAnnotation extends FlowTypeAnnotation {
        params: FunctionTypeParam[];
        returnType: FlowTypeAnnotation;
        rest?: FunctionTypeParam | null;
        typeParameters?: TypeParameterDeclaration | null;
    }

    interface FunctionTypeParam {
        name: Identifier;
        typeAnnotation: FlowTypeAnnotation;
        optional: boolean;
    }

    interface GenericTypeAnnotation extends FlowTypeAnnotation {
        id: Identifier | QualifiedTypeIdentifier;
        typeParameters?: TypeParameterInstantiation | null;
    }

    interface InterfaceExtends extends Node {
        id: Identifier | QualifiedTypeIdentifier;
        typeParameters?: TypeParameterInstantiation | null;
    }

    interface InterfaceDeclaration extends FlowDeclaration {
        id: Identifier;
        typeParameters?: TypeParameterDeclaration | null;
        extends: InterfaceExtends[];
        body: ObjectTypeAnnotation;
    }

    interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
        types: FlowTypeAnnotation[];
    }

    interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface NullableTypeAnnotation extends FlowTypeAnnotation {
        typeAnnotation: TypeAnnotation;
    }

    interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}

    interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}

    interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}

    interface TupleTypeAnnotation extends FlowTypeAnnotation {
        types: FlowTypeAnnotation[];
    }

    interface TypeofTypeAnnotation extends FlowTypeAnnotation {
        argument: FlowTypeAnnotation;
    }

    interface TypeAlias extends FlowDeclaration {
        id: Identifier;
        typeParameters?: TypeParameterDeclaration | null;
        right: FlowTypeAnnotation;
    }

    interface TypeAnnotation extends Node {
        typeAnnotation: FlowTypeAnnotation;
    }

    interface TypeCastExpression extends Expression {
        expression: Expression;
        typeAnnotation: TypeAnnotation;
    }

    interface TypeParameterDeclaration extends Node {
        params: Identifier[];
    }

    interface TypeParameterInstantiation extends Node {
        params: FlowTypeAnnotation[];
    }

    interface ObjectTypeAnnotation extends FlowTypeAnnotation {
        properties: ObjectTypeProperty[];
        indexers: ObjectTypeIndexer[];
        callProperties: ObjectTypeCallProperty[];
    }

    interface ObjectTypeCallProperty extends Node {
        value: FunctionTypeAnnotation;
        static: boolean;
    }

    interface ObjectTypeIndexer extends Node {
        id: Identifier;
        key: FlowTypeAnnotation;
        value: FlowTypeAnnotation;
        static: boolean;
    }

    interface ObjectTypeProperty extends Node {
        key: Expression;
        value: FlowTypeAnnotation;
        optional: boolean;
        static: boolean;
    }

    interface QualifiedTypeIdentifier extends Node {
        qualification: Identifier | QualifiedTypeIdentifier;
        id: Identifier;
    }

    interface UnionTypeAnnotation extends FlowTypeAnnotation {
        types: FlowTypeAnnotation[];
    }

    interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
}
=== END FILE ===
=== START FILE: ./node_modules/@types/estree/index.d.ts ===
// This definition file follows a somewhat unusual format. ESTree allows
// runtime type checks based on the `type` parameter. In order to explain this
// to typescript we want to use discriminated union types:
// https://github.com/Microsoft/TypeScript/pull/9163
//
// For ESTree this is a bit tricky because the high level interfaces like
// Node or Function are pulling double duty. We want to pass common fields down
// to the interfaces that extend them (like Identifier or
// ArrowFunctionExpression), but you can't extend a type union or enforce
// common fields on them. So we've split the high level interfaces into two
// types, a base type which passes down inherited fields, and a type union of
// all types which extend the base type. Only the type union is exported, and
// the union is how other types refer to the collection of inheriting types.
//
// This makes the definitions file here somewhat more difficult to maintain,
// but it has the notable advantage of making ESTree much easier to use as
// an end user.

export interface BaseNodeWithoutComments {
    // Every leaf interface that extends BaseNode must specify a type property.
    // The type property should be a string literal. For example, Identifier
    // has: `type: "Identifier"`
    type: string;
    loc?: SourceLocation | null | undefined;
    range?: [number, number] | undefined;
}

export interface BaseNode extends BaseNodeWithoutComments {
    leadingComments?: Comment[] | undefined;
    trailingComments?: Comment[] | undefined;
}

export interface NodeMap {
    AssignmentProperty: AssignmentProperty;
    CatchClause: CatchClause;
    Class: Class;
    ClassBody: ClassBody;
    Expression: Expression;
    Function: Function;
    Identifier: Identifier;
    Literal: Literal;
    MethodDefinition: MethodDefinition;
    ModuleDeclaration: ModuleDeclaration;
    ModuleSpecifier: ModuleSpecifier;
    Pattern: Pattern;
    PrivateIdentifier: PrivateIdentifier;
    Program: Program;
    Property: Property;
    PropertyDefinition: PropertyDefinition;
    SpreadElement: SpreadElement;
    Statement: Statement;
    Super: Super;
    SwitchCase: SwitchCase;
    TemplateElement: TemplateElement;
    VariableDeclarator: VariableDeclarator;
}

export type Node = NodeMap[keyof NodeMap];

export interface Comment extends BaseNodeWithoutComments {
    type: "Line" | "Block";
    value: string;
}

export interface SourceLocation {
    source?: string | null | undefined;
    start: Position;
    end: Position;
}

export interface Position {
    /** >= 1 */
    line: number;
    /** >= 0 */
    column: number;
}

export interface Program extends BaseNode {
    type: "Program";
    sourceType: "script" | "module";
    body: Array<Directive | Statement | ModuleDeclaration>;
    comments?: Comment[] | undefined;
}

export interface Directive extends BaseNode {
    type: "ExpressionStatement";
    expression: Literal;
    directive: string;
}

export interface BaseFunction extends BaseNode {
    params: Pattern[];
    generator?: boolean | undefined;
    async?: boolean | undefined;
    // The body is either BlockStatement or Expression because arrow functions
    // can have a body that's either. FunctionDeclarations and
    // FunctionExpressions have only BlockStatement bodies.
    body: BlockStatement | Expression;
}

export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;

export type Statement =
    | ExpressionStatement
    | BlockStatement
    | StaticBlock
    | EmptyStatement
    | DebuggerStatement
    | WithStatement
    | ReturnStatement
    | LabeledStatement
    | BreakStatement
    | ContinueStatement
    | IfStatement
    | SwitchStatement
    | ThrowStatement
    | TryStatement
    | WhileStatement
    | DoWhileStatement
    | ForStatement
    | ForInStatement
    | ForOfStatement
    | Declaration;

export interface BaseStatement extends BaseNode {}

export interface EmptyStatement extends BaseStatement {
    type: "EmptyStatement";
}

export interface BlockStatement extends BaseStatement {
    type: "BlockStatement";
    body: Statement[];
    innerComments?: Comment[] | undefined;
}

export interface StaticBlock extends Omit<BlockStatement, "type"> {
    type: "StaticBlock";
}

export interface ExpressionStatement extends BaseStatement {
    type: "ExpressionStatement";
    expression: Expression;
}

export interface IfStatement extends BaseStatement {
    type: "IfStatement";
    test: Expression;
    consequent: Statement;
    alternate?: Statement | null | undefined;
}

export interface LabeledStatement extends BaseStatement {
    type: "LabeledStatement";
    label: Identifier;
    body: Statement;
}

export interface BreakStatement extends BaseStatement {
    type: "BreakStatement";
    label?: Identifier | null | undefined;
}

export interface ContinueStatement extends BaseStatement {
    type: "ContinueStatement";
    label?: Identifier | null | undefined;
}

export interface WithStatement extends BaseStatement {
    type: "WithStatement";
    object: Expression;
    body: Statement;
}

export interface SwitchStatement extends BaseStatement {
    type: "SwitchStatement";
    discriminant: Expression;
    cases: SwitchCase[];
}

export interface ReturnStatement extends BaseStatement {
    type: "ReturnStatement";
    argument?: Expression | null | undefined;
}

export interface ThrowStatement extends BaseStatement {
    type: "ThrowStatement";
    argument: Expression;
}

export interface TryStatement extends BaseStatement {
    type: "TryStatement";
    block: BlockStatement;
    handler?: CatchClause | null | undefined;
    finalizer?: BlockStatement | null | undefined;
}

export interface WhileStatement extends BaseStatement {
    type: "WhileStatement";
    test: Expression;
    body: Statement;
}

export interface DoWhileStatement extends BaseStatement {
    type: "DoWhileStatement";
    body: Statement;
    test: Expression;
}

export interface ForStatement extends BaseStatement {
    type: "ForStatement";
    init?: VariableDeclaration | Expression | null | undefined;
    test?: Expression | null | undefined;
    update?: Expression | null | undefined;
    body: Statement;
}

export interface BaseForXStatement extends BaseStatement {
    left: VariableDeclaration | Pattern;
    right: Expression;
    body: Statement;
}

export interface ForInStatement extends BaseForXStatement {
    type: "ForInStatement";
}

export interface DebuggerStatement extends BaseStatement {
    type: "DebuggerStatement";
}

export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;

export interface BaseDeclaration extends BaseStatement {}

export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
    type: "FunctionDeclaration";
    /** It is null when a function declaration is a part of the `export default function` statement */
    id: Identifier | null;
    body: BlockStatement;
}

export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
    id: Identifier;
}

export interface VariableDeclaration extends BaseDeclaration {
    type: "VariableDeclaration";
    declarations: VariableDeclarator[];
    kind: "var" | "let" | "const";
}

export interface VariableDeclarator extends BaseNode {
    type: "VariableDeclarator";
    id: Pattern;
    init?: Expression | null | undefined;
}

export interface ExpressionMap {
    ArrayExpression: ArrayExpression;
    ArrowFunctionExpression: ArrowFunctionExpression;
    AssignmentExpression: AssignmentExpression;
    AwaitExpression: AwaitExpression;
    BinaryExpression: BinaryExpression;
    CallExpression: CallExpression;
    ChainExpression: ChainExpression;
    ClassExpression: ClassExpression;
    ConditionalExpression: ConditionalExpression;
    FunctionExpression: FunctionExpression;
    Identifier: Identifier;
    ImportExpression: ImportExpression;
    Literal: Literal;
    LogicalExpression: LogicalExpression;
    MemberExpression: MemberExpression;
    MetaProperty: MetaProperty;
    NewExpression: NewExpression;
    ObjectExpression: ObjectExpression;
    SequenceExpression: SequenceExpression;
    TaggedTemplateExpression: TaggedTemplateExpression;
    TemplateLiteral: TemplateLiteral;
    ThisExpression: ThisExpression;
    UnaryExpression: UnaryExpression;
    UpdateExpression: UpdateExpression;
    YieldExpression: YieldExpression;
}

export type Expression = ExpressionMap[keyof ExpressionMap];

export interface BaseExpression extends BaseNode {}

export type ChainElement = SimpleCallExpression | MemberExpression;

export interface ChainExpression extends BaseExpression {
    type: "ChainExpression";
    expression: ChainElement;
}

export interface ThisExpression extends BaseExpression {
    type: "ThisExpression";
}

export interface ArrayExpression extends BaseExpression {
    type: "ArrayExpression";
    elements: Array<Expression | SpreadElement | null>;
}

export interface ObjectExpression extends BaseExpression {
    type: "ObjectExpression";
    properties: Array<Property | SpreadElement>;
}

export interface PrivateIdentifier extends BaseNode {
    type: "PrivateIdentifier";
    name: string;
}

export interface Property extends BaseNode {
    type: "Property";
    key: Expression | PrivateIdentifier;
    value: Expression | Pattern; // Could be an AssignmentProperty
    kind: "init" | "get" | "set";
    method: boolean;
    shorthand: boolean;
    computed: boolean;
}

export interface PropertyDefinition extends BaseNode {
    type: "PropertyDefinition";
    key: Expression | PrivateIdentifier;
    value?: Expression | null | undefined;
    computed: boolean;
    static: boolean;
}

export interface FunctionExpression extends BaseFunction, BaseExpression {
    id?: Identifier | null | undefined;
    type: "FunctionExpression";
    body: BlockStatement;
}

export interface SequenceExpression extends BaseExpression {
    type: "SequenceExpression";
    expressions: Expression[];
}

export interface UnaryExpression extends BaseExpression {
    type: "UnaryExpression";
    operator: UnaryOperator;
    prefix: true;
    argument: Expression;
}

export interface BinaryExpression extends BaseExpression {
    type: "BinaryExpression";
    operator: BinaryOperator;
    left: Expression | PrivateIdentifier;
    right: Expression;
}

export interface AssignmentExpression extends BaseExpression {
    type: "AssignmentExpression";
    operator: AssignmentOperator;
    left: Pattern | MemberExpression;
    right: Expression;
}

export interface UpdateExpression extends BaseExpression {
    type: "UpdateExpression";
    operator: UpdateOperator;
    argument: Expression;
    prefix: boolean;
}

export interface LogicalExpression extends BaseExpression {
    type: "LogicalExpression";
    operator: LogicalOperator;
    left: Expression;
    right: Expression;
}

export interface ConditionalExpression extends BaseExpression {
    type: "ConditionalExpression";
    test: Expression;
    alternate: Expression;
    consequent: Expression;
}

export interface BaseCallExpression extends BaseExpression {
    callee: Expression | Super;
    arguments: Array<Expression | SpreadElement>;
}
export type CallExpression = SimpleCallExpression | NewExpression;

export interface SimpleCallExpression extends BaseCallExpression {
    type: "CallExpression";
    optional: boolean;
}

export interface NewExpression extends BaseCallExpression {
    type: "NewExpression";
}

export interface MemberExpression extends BaseExpression, BasePattern {
    type: "MemberExpression";
    object: Expression | Super;
    property: Expression | PrivateIdentifier;
    computed: boolean;
    optional: boolean;
}

export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;

export interface BasePattern extends BaseNode {}

export interface SwitchCase extends BaseNode {
    type: "SwitchCase";
    test?: Expression | null | undefined;
    consequent: Statement[];
}

export interface CatchClause extends BaseNode {
    type: "CatchClause";
    param: Pattern | null;
    body: BlockStatement;
}

export interface Identifier extends BaseNode, BaseExpression, BasePattern {
    type: "Identifier";
    name: string;
}

export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;

export interface SimpleLiteral extends BaseNode, BaseExpression {
    type: "Literal";
    value: string | boolean | number | null;
    raw?: string | undefined;
}

export interface RegExpLiteral extends BaseNode, BaseExpression {
    type: "Literal";
    value?: RegExp | null | undefined;
    regex: {
        pattern: string;
        flags: string;
    };
    raw?: string | undefined;
}

export interface BigIntLiteral extends BaseNode, BaseExpression {
    type: "Literal";
    value?: bigint | null | undefined;
    bigint: string;
    raw?: string | undefined;
}

export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";

export type BinaryOperator =
    | "=="
    | "!="
    | "==="
    | "!=="
    | "<"
    | "<="
    | ">"
    | ">="
    | "<<"
    | ">>"
    | ">>>"
    | "+"
    | "-"
    | "*"
    | "/"
    | "%"
    | "**"
    | "|"
    | "^"
    | "&"
    | "in"
    | "instanceof";

export type LogicalOperator = "||" | "&&" | "??";

export type AssignmentOperator =
    | "="
    | "+="
    | "-="
    | "*="
    | "/="
    | "%="
    | "**="
    | "<<="
    | ">>="
    | ">>>="
    | "|="
    | "^="
    | "&="
    | "||="
    | "&&="
    | "??=";

export type UpdateOperator = "++" | "--";

export interface ForOfStatement extends BaseForXStatement {
    type: "ForOfStatement";
    await: boolean;
}

export interface Super extends BaseNode {
    type: "Super";
}

export interface SpreadElement extends BaseNode {
    type: "SpreadElement";
    argument: Expression;
}

export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
    type: "ArrowFunctionExpression";
    expression: boolean;
    body: BlockStatement | Expression;
}

export interface YieldExpression extends BaseExpression {
    type: "YieldExpression";
    argument?: Expression | null | undefined;
    delegate: boolean;
}

export interface TemplateLiteral extends BaseExpression {
    type: "TemplateLiteral";
    quasis: TemplateElement[];
    expressions: Expression[];
}

export interface TaggedTemplateExpression extends BaseExpression {
    type: "TaggedTemplateExpression";
    tag: Expression;
    quasi: TemplateLiteral;
}

export interface TemplateElement extends BaseNode {
    type: "TemplateElement";
    tail: boolean;
    value: {
        /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
        cooked?: string | null | undefined;
        raw: string;
    };
}

export interface AssignmentProperty extends Property {
    value: Pattern;
    kind: "init";
    method: boolean; // false
}

export interface ObjectPattern extends BasePattern {
    type: "ObjectPattern";
    properties: Array<AssignmentProperty | RestElement>;
}

export interface ArrayPattern extends BasePattern {
    type: "ArrayPattern";
    elements: Array<Pattern | null>;
}

export interface RestElement extends BasePattern {
    type: "RestElement";
    argument: Pattern;
}

export interface AssignmentPattern extends BasePattern {
    type: "AssignmentPattern";
    left: Pattern;
    right: Expression;
}

export type Class = ClassDeclaration | ClassExpression;
export interface BaseClass extends BaseNode {
    superClass?: Expression | null | undefined;
    body: ClassBody;
}

export interface ClassBody extends BaseNode {
    type: "ClassBody";
    body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
}

export interface MethodDefinition extends BaseNode {
    type: "MethodDefinition";
    key: Expression | PrivateIdentifier;
    value: FunctionExpression;
    kind: "constructor" | "method" | "get" | "set";
    computed: boolean;
    static: boolean;
}

export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
    type: "ClassDeclaration";
    /** It is null when a class declaration is a part of the `export default class` statement */
    id: Identifier | null;
}

export interface ClassDeclaration extends MaybeNamedClassDeclaration {
    id: Identifier;
}

export interface ClassExpression extends BaseClass, BaseExpression {
    type: "ClassExpression";
    id?: Identifier | null | undefined;
}

export interface MetaProperty extends BaseExpression {
    type: "MetaProperty";
    meta: Identifier;
    property: Identifier;
}

export type ModuleDeclaration =
    | ImportDeclaration
    | ExportNamedDeclaration
    | ExportDefaultDeclaration
    | ExportAllDeclaration;
export interface BaseModuleDeclaration extends BaseNode {}

export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
export interface BaseModuleSpecifier extends BaseNode {
    local: Identifier;
}

export interface ImportDeclaration extends BaseModuleDeclaration {
    type: "ImportDeclaration";
    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
    attributes: ImportAttribute[];
    source: Literal;
}

export interface ImportSpecifier extends BaseModuleSpecifier {
    type: "ImportSpecifier";
    imported: Identifier | Literal;
}

export interface ImportAttribute extends BaseNode {
    type: "ImportAttribute";
    key: Identifier | Literal;
    value: Literal;
}

export interface ImportExpression extends BaseExpression {
    type: "ImportExpression";
    source: Expression;
    options?: Expression | null | undefined;
}

export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
    type: "ImportDefaultSpecifier";
}

export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
    type: "ImportNamespaceSpecifier";
}

export interface ExportNamedDeclaration extends BaseModuleDeclaration {
    type: "ExportNamedDeclaration";
    declaration?: Declaration | null | undefined;
    specifiers: ExportSpecifier[];
    attributes: ImportAttribute[];
    source?: Literal | null | undefined;
}

export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
    type: "ExportSpecifier";
    local: Identifier | Literal;
    exported: Identifier | Literal;
}

export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
    type: "ExportDefaultDeclaration";
    declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
}

export interface ExportAllDeclaration extends BaseModuleDeclaration {
    type: "ExportAllDeclaration";
    exported: Identifier | Literal | null;
    attributes: ImportAttribute[];
    source: Literal;
}

export interface AwaitExpression extends BaseExpression {
    type: "AwaitExpression";
    argument: Expression;
}
=== END FILE ===
=== START FILE: ./node_modules/@types/resize-observer-browser/index.d.ts ===
interface Window {
    ResizeObserver: typeof ResizeObserver;
}

interface ResizeObserverOptions {
    /**
     * Sets which box model the observer will observe changes to. Possible values
     * are `content-box` (the default), and `border-box`.
     *
     * @default 'content-box'
     */
    box?: "content-box" | "border-box" | "device-pixel-content-box" | undefined;
}

interface ResizeObserverSize {
    readonly inlineSize: number;
    readonly blockSize: number;
}

interface ResizeObserver {
    disconnect(): void;
    observe(target: Element, options?: ResizeObserverOptions): void;
    unobserve(target: Element): void;
}

declare var ResizeObserver: {
    new(callback: ResizeObserverCallback): ResizeObserver;
    prototype: ResizeObserver;
};

interface ResizeObserverCallback {
    (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
}

interface ResizeObserverEntry {
    readonly target: Element;
    readonly contentRect: DOMRectReadOnly;
    readonly borderBoxSize: readonly ResizeObserverSize[];
    readonly contentBoxSize: readonly ResizeObserverSize[];
    readonly devicePixelContentBoxSize: readonly ResizeObserverSize[];
}
=== END FILE ===
=== START FILE: ./node_modules/@types/hast/index.d.ts ===
import type { Data as UnistData, Literal as UnistLiteral, Node as UnistNode, Parent as UnistParent } from "unist";

// ## Interfaces

/**
 * Info associated with hast nodes by the ecosystem.
 *
 * This space is guaranteed to never be specified by unist or hast.
 * But you can use it in utilities and plugins to store data.
 *
 * This type can be augmented to register custom data.
 * For example:
 *
 * ```ts
 * declare module 'hast' {
 *   interface Data {
 *     // `someNode.data.myId` is typed as `number | undefined`
 *     myId?: number | undefined
 *   }
 * }
 * ```
 */
export interface Data extends UnistData {}

/**
 * Info associated with an element.
 */
export interface Properties {
    [PropertyName: string]: boolean | number | string | null | undefined | Array<string | number>;
}

// ## Content maps

/**
 * Union of registered hast nodes that can occur in {@link Element}.
 *
 * To register mote custom hast nodes, add them to {@link ElementContentMap}.
 * They will be automatically added here.
 */
export type ElementContent = ElementContentMap[keyof ElementContentMap];

/**
 * Registry of all hast nodes that can occur as children of {@link Element}.
 *
 * For a union of all {@link Element} children, see {@link ElementContent}.
 */
export interface ElementContentMap {
    comment: Comment;
    element: Element;
    text: Text;
}

/**
 * Union of registered hast nodes that can occur in {@link Root}.
 *
 * To register custom hast nodes, add them to {@link RootContentMap}.
 * They will be automatically added here.
 */
export type RootContent = RootContentMap[keyof RootContentMap];

/**
 * Registry of all hast nodes that can occur as children of {@link Root}.
 *
 * > 👉 **Note**: {@link Root} does not need to be an entire document.
 * > it can also be a fragment.
 *
 * For a union of all {@link Root} children, see {@link RootContent}.
 */
export interface RootContentMap {
    comment: Comment;
    doctype: Doctype;
    element: Element;
    text: Text;
}

// ### Special content types

/**
 * Union of registered hast nodes that can occur in {@link Root}.
 *
 * @deprecated Use {@link RootContent} instead.
 */
export type Content = RootContent;

/**
 * Union of registered hast literals.
 *
 * To register custom hast nodes, add them to {@link RootContentMap} and other
 * places where relevant.
 * They will be automatically added here.
 */
export type Literals = Extract<Nodes, UnistLiteral>;

/**
 * Union of registered hast nodes.
 *
 * To register custom hast nodes, add them to {@link RootContentMap} and other
 * places where relevant.
 * They will be automatically added here.
 */
export type Nodes = Root | RootContent;

/**
 * Union of registered hast parents.
 *
 * To register custom hast nodes, add them to {@link RootContentMap} and other
 * places where relevant.
 * They will be automatically added here.
 */
export type Parents = Extract<Nodes, UnistParent>;

// ## Abstract nodes

/**
 * Abstract hast node.
 *
 * This interface is supposed to be extended.
 * If you can use {@link Literal} or {@link Parent}, you should.
 * But for example in HTML, a `Doctype` is neither literal nor parent, but
 * still a node.
 *
 * To register custom hast nodes, add them to {@link RootContentMap} and other
 * places where relevant (such as {@link ElementContentMap}).
 *
 * For a union of all registered hast nodes, see {@link Nodes}.
 */
export interface Node extends UnistNode {
    /**
     * Info from the ecosystem.
     */
    data?: Data | undefined;
}

/**
 * Abstract hast node that contains the smallest possible value.
 *
 * This interface is supposed to be extended if you make custom hast nodes.
 *
 * For a union of all registered hast literals, see {@link Literals}.
 */
export interface Literal extends Node {
    /**
     * Plain-text value.
     */
    value: string;
}

/**
 * Abstract hast node that contains other hast nodes (*children*).
 *
 * This interface is supposed to be extended if you make custom hast nodes.
 *
 * For a union of all registered hast parents, see {@link Parents}.
 */
export interface Parent extends Node {
    /**
     * List of children.
     */
    children: RootContent[];
}

// ## Concrete nodes

/**
 * HTML comment.
 */
export interface Comment extends Literal {
    /**
     * Node type of HTML comments in hast.
     */
    type: "comment";
    /**
     * Data associated with the comment.
     */
    data?: CommentData | undefined;
}

/**
 * Info associated with hast comments by the ecosystem.
 */
export interface CommentData extends Data {}

/**
 * HTML document type.
 */
export interface Doctype extends UnistNode {
    /**
     * Node type of HTML document types in hast.
     */
    type: "doctype";
    /**
     * Data associated with the doctype.
     */
    data?: DoctypeData | undefined;
}

/**
 * Info associated with hast doctypes by the ecosystem.
 */
export interface DoctypeData extends Data {}

/**
 * HTML element.
 */
export interface Element extends Parent {
    /**
     * Node type of elements.
     */
    type: "element";
    /**
     * Tag name (such as `'body'`) of the element.
     */
    tagName: string;
    /**
     * Info associated with the element.
     */
    properties: Properties;
    /**
     * Children of element.
     */
    children: ElementContent[];
    /**
     * When the `tagName` field is `'template'`, a `content` field can be
     * present.
     */
    content?: Root | undefined;
    /**
     * Data associated with the element.
     */
    data?: ElementData | undefined;
}

/**
 * Info associated with hast elements by the ecosystem.
 */
export interface ElementData extends Data {}

/**
 * Document fragment or a whole document.
 *
 * Should be used as the root of a tree and must not be used as a child.
 *
 * Can also be used as the value for the content field on a `'template'` element.
 */
export interface Root extends Parent {
    /**
     * Node type of hast root.
     */
    type: "root";
    /**
     * Children of root.
     */
    children: RootContent[];
    /**
     * Data associated with the hast root.
     */
    data?: RootData | undefined;
}

/**
 * Info associated with hast root nodes by the ecosystem.
 */
export interface RootData extends Data {}

/**
 * HTML character data (plain text).
 */
export interface Text extends Literal {
    /**
     * Node type of HTML character data (plain text) in hast.
     */
    type: "text";
    /**
     * Data associated with the text.
     */
    data?: TextData | undefined;
}

/**
 * Info associated with hast texts by the ecosystem.
 */
export interface TextData extends Data {}
=== END FILE ===
=== START FILE: ./node_modules/@types/yauzl/index.d.ts ===
/// <reference types="node" />

import { EventEmitter } from "events";
import { Readable } from "stream";

export abstract class RandomAccessReader extends EventEmitter {
    _readStreamForRange(start: number, end: number): void;
    createReadStream(options: { start: number; end: number }): void;
    read(buffer: Buffer, offset: number, length: number, position: number, callback: (err: Error | null) => void): void;
    close(callback: (err: Error | null) => void): void;
}

export class Entry {
    comment: string;
    compressedSize: number;
    compressionMethod: number;
    crc32: number;
    externalFileAttributes: number;
    extraFieldLength: number;
    extraFields: Array<{ id: number; data: Buffer }>;
    fileCommentLength: number;
    fileName: string;
    fileNameLength: number;
    generalPurposeBitFlag: number;
    internalFileAttributes: number;
    lastModFileDate: number;
    lastModFileTime: number;
    relativeOffsetOfLocalHeader: number;
    uncompressedSize: number;
    versionMadeBy: number;
    versionNeededToExtract: number;

    getLastModDate(): Date;
    isEncrypted(): boolean;
    isCompressed(): boolean;
}

export interface ZipFileOptions {
    decompress: boolean | null;
    decrypt: boolean | null;
    start: number | null;
    end: number | null;
}

export class ZipFile extends EventEmitter {
    autoClose: boolean;
    comment: string;
    decodeStrings: boolean;
    emittedError: boolean;
    entriesRead: number;
    entryCount: number;
    fileSize: number;
    isOpen: boolean;
    lazyEntries: boolean;
    readEntryCursor: boolean;
    validateEntrySizes: boolean;

    constructor(
        reader: RandomAccessReader,
        centralDirectoryOffset: number,
        fileSize: number,
        entryCount: number,
        comment: string,
        autoClose: boolean,
        lazyEntries: boolean,
        decodeStrings: boolean,
        validateEntrySizes: boolean,
    );

    openReadStream(
        entry: Entry,
        options: ZipFileOptions,
        callback: (err: Error | null, stream: Readable) => void,
    ): void;
    openReadStream(entry: Entry, callback: (err: Error | null, stream: Readable) => void): void;
    close(): void;
    readEntry(): void;
}

export interface Options {
    autoClose?: boolean | undefined;
    lazyEntries?: boolean | undefined;
    decodeStrings?: boolean | undefined;
    validateEntrySizes?: boolean | undefined;
    strictFileNames?: boolean | undefined;
}

export function open(path: string, options: Options, callback?: (err: Error | null, zipfile: ZipFile) => void): void;
export function open(path: string, callback?: (err: Error | null, zipfile: ZipFile) => void): void;
export function fromFd(fd: number, options: Options, callback?: (err: Error | null, zipfile: ZipFile) => void): void;
export function fromFd(fd: number, callback?: (err: Error | null, zipfile: ZipFile) => void): void;
export function fromBuffer(
    buffer: Buffer,
    options: Options,
    callback?: (err: Error | null, zipfile: ZipFile) => void,
): void;
export function fromBuffer(buffer: Buffer, callback?: (err: Error | null, zipfile: ZipFile) => void): void;
export function fromRandomAccessReader(
    reader: RandomAccessReader,
    totalSize: number,
    options: Options,
    callback: (err: Error | null, zipfile: ZipFile) => void,
): void;
export function fromRandomAccessReader(
    reader: RandomAccessReader,
    totalSize: number,
    callback: (err: Error | null, zipfile: ZipFile) => void,
): void;
export function dosDateTimeToDate(date: number, time: number): Date;
export function validateFileName(fileName: string): string | null;
=== END FILE ===
=== START FILE: ./node_modules/@types/tar/index.d.ts ===
/// <reference types="node" />

import stream = require("stream");
import zlib = require("zlib");
import MiniPass = require("minipass");
import fs = require("fs");

// #region Interfaces

export interface HeaderProperties {
    path: string;
    mode?: number | undefined;
    noProprietary?: boolean | undefined;
    uid?: number | undefined;
    gid?: number | undefined;
    size?: number | undefined;
    mtime?: number | undefined;
    type?: string | undefined;
    uname?: string | undefined;
    gname?: string | undefined;
    devmaj?: number | undefined;
    devmin?: number | undefined;
}

export interface ParseStream extends NodeJS.ReadWriteStream {
    position: number;

    _stream: stream.Stream;
    _ended: boolean;

    _streamEnd(): void;
    _process(c: Buffer): void;
    _startEntry(c: Buffer): void;
}

export interface PackStream extends NodeJS.ReadWriteStream {
    writable: boolean;
    readable: boolean;

    _noProprietary: boolean;
    _global: HeaderProperties;
    _buffer: stream.Stream[];
    _currentEntry: any;
    _processing: boolean;
    _pipeRoot: stream.Stream;
    _needDrain: boolean;
    _paused: boolean;

    addGlobal(props: HeaderProperties): void;
    add(stream: stream.Stream): boolean;
    destroy(): void;

    _process(): void;
}

// #endregion

// #region Enums

export interface Fields {
    path: number;
    mode: number;
    uid: number;
    gid: number;
    size: number;
    mtime: number;
    cksum: number;
    type: number;
    linkpath: number;
    ustar: number;
    ustarvar: number;
    uname: number;
    gname: number;
    devmaj: number;
    devmin: number;
    prefix: number;
    fill: number;
}

export type fields = Fields; // alias for backwards compatbility

export const fieldSize: number[];
export const fieldOffs: number[];
export const fieldEnds: number[];

/**
 * Different values of the 'type' field
 * paths match the values of Stats.isX() functions, where appropriate
 */
export const types: {
    0: string;
    "\0": string;
    "": string;
    1: string;
    2: string;
    3: string;
    4: string;
    5: string;
    6: string;
    7: string;
    g: string;
    x: string;
    A: string;
    D: string;
    I: string;
    K: string;
    L: string;
    M: string;
    N: string;
    S: string;
    V: string;
    X: string;
    File: string;
    OldFile: string;
    Link: string;
    SymbolicLick: string;
    CharacterDevice: string;
    BlockDevice: string;
    Directory: string;
    FIFO: string;
    ContiguousFile: string;
    GlobalExtendedHeader: string;
    ExtendedHeader: string;
    SolarisACL: string;
    GNUDumpDir: string;
    INode: string;
    NextFileHasLonLinkPath: string;
    NextFileHasLongPath: string;
    ContinuationFile: string;
    TapeVolumeHeader: string;
    OldExtendedHeader: string;
};

/**
 * Values for the mode field
 */
export const modes: {
    suid: number;
    sgid: number;
    svtx: number;
    uread: number;
    uwrite: number;
    uexec: number;
    gread: number;
    gwrite: number;
    gexec: number;
    oread: number;
    owrite: number;
    oexec: number;
};

export const numeric: {
    mode: boolean;
    uid: boolean;
    gid: boolean;
    size: boolean;
    mtime: boolean;
    devmaj: boolean;
    devmin: boolean;
    cksum: boolean;
    atime: boolean;
    ctime: boolean;
    dev: boolean;
    ino: boolean;
    nlink: boolean;
};

export const knownExtended: {
    atime: boolean;
    charset: boolean;
    comment: boolean;
    ctime: boolean;
    gid: boolean;
    gname: boolean;
    linkpat: boolean;
    mtime: boolean;
    path: boolean;
    realtime: boolean;
    security: boolean;
    size: boolean;
    uid: boolean;
    uname: boolean;
};

export const headerSize: number;
export const blockSize: number;

export interface ParseOptions {
    strict?: boolean;
    filter?: (path: string, entry: ReadEntry) => boolean;
    onentry?: (entry: ReadEntry) => void;
    onwarn?: (code: string, message: string, data: Buffer) => void;
}
/**
 * A writable stream. Write tar data to it and it will emit entry events for each entry parsed from the tarball. This is used by tar.Extract.
 */
export interface Parse extends ParseStream {
    on(event: "end" | "close", listener: () => void): this;
    on(event: "entry", listener: (entry: ReadEntry) => void): this;
}

export const Parse: {
    new(opt?: ParseOptions): Parse;
};
// #endregion

// #region Global Methods

export interface PackOptions {
    /**
     * A function that will get called with (code, message, data) for any
     * warnings encountered. (See "Warnings and Errors")
     */
    onwarn?(code: string, message: string, data: Buffer): void;
    /**
     * Treat warnings as crash-worthy errors.
     *
     * @default false
     */
    strict?: boolean;
    /**
     * The current working directory for creating the archive.
     *
     * @default process.cwd()
     */
    cwd?: string;
    /**
     * A path portion to prefix onto the entries in the archive.
     */
    prefix?: string;
    /**
     * Set to any truthy value to create a gzipped archive, or an object with
     * settings for zlib.Gzip()
     */
    gzip?: boolean | zlib.ZlibOptions;
    /**
     * Set to any truthy value to create a brotli-compressed archive,
     * or an object with settings for zlib.BrotliCompress()
     */
    brotli?: boolean | zlib.BrotliOptions;
    /**
     * A function that gets called with (path, stat) for each entry being added.
     * Return true to add the entry to the archive, or false to omit it.
     */
    filter?(path: string, stat: fs.Stats): boolean;
    /**
     * Omit metadata that is system-specific: ctime, atime, uid, gid, uname,
     * gname, dev, ino, and nlink. Note that mtime is still included, because
     * this is necessary for other time-based operations. Additionally, mode is
     * set to a "reasonable default" for most unix systems, based on a umask
     * value of 0o22.
     */
    portable?: boolean;
    /**
     * Allow absolute paths. By default, / is stripped from absolute paths.
     */
    preservePaths?: boolean;
    /**
     * A Map object containing the device and inode value for any file whose
     * nlink is > 1, to identify hard links.
     */
    linkCache?: Map<string, string>;
    /**
     * A Map object that caches calls lstat.
     */
    statCache?: Map<string, string>;
    /**
     * A Map object that caches calls to readdir.
     */
    readdirCache?: Map<string, string>;
    /**
     * A number specifying how many concurrent jobs to run.
     *
     * @default 4
     */
    jobs?: number;
    /**
     * The maximum buffer size for fs.read() operations.
     *
     * @default 16 MB
     */
    maxReadSize?: number;
    /**
     * Do not recursively archive the contents of directories.
     */
    noDirRecurse?: boolean;
    /**
     * Set to true to pack the targets of symbolic links. Without this option,
     * symbolic links are archived as such.
     */
    follow?: boolean;
    /**
     * Suppress pax extended headers. Note that this means that long paths and
     * linkpaths will be truncated, and large or negative numeric values may be
     * interpreted incorrectly.
     */
    noPax?: boolean;
    /**
     * Set to true to omit writing mtime values for entries. Note that this
     * prevents using other mtime-based features like tar.update or the
     * keepNewer option with the resulting tar archive.
     */
    noMtime?: boolean;
    /**
     * Set to a Date object to force a specific mtime for everything added to
     * the archive. Overridden by noMtime.
     */
    mtime?: Date;
}

/**
 * Returns a through stream. Use fstream to write files into the pack stream and you will receive tar archive data from the pack stream.
 * This only works with directories, it does not work with individual files.
 * The optional properties object are used to set properties in the tar 'Global Extended Header'.
 */
export class Pack extends MiniPass {
    linkCache: PackOptions["linkCache"];
    readdirCache: PackOptions["readdirCache"];
    statCache: PackOptions["statCache"];

    static Sync: typeof PackSync;

    constructor(opt?: PackOptions);

    add(path: string): this;
}

declare class PackSync extends Pack {
    constructor(opt: PackOptions);

    // pause/resume are no-ops in sync streams.
    pause(): void;
    resume(): void;
}

declare class PackJob {
    path: string;
    absolute: string;
    entry: unknown | null;
    stat: unknown | null;
    readdir: unknown | null;
    pending: boolean;
    ignore: boolean;
    piped: boolean;

    constructor(path?: string, absolute?: string);
}

/**
 * Returns a through stream. Write tar data to the stream and the files in the tarball will be extracted onto the filesystem.
 * options can be:
 * ```
 * {
 *   path: '/path/to/extract/tar/into',
 *   strip: 0, // how many path segments to strip from the root when extracting
 * }
 * ```
 * options also get passed to the fstream.Writer instance that tar uses internally.
 */
export function Extract(opts: ExtractOptions | string): ParseStream;

export interface FileStat extends stream.Readable, Fields {
    header: HeaderProperties;
    startBlockSize: number;
    blockRemain: number;
    remain: number;
    meta: boolean;
    ignore: boolean;
    size: number;
}

export interface ReadEntry extends MiniPass, HeaderProperties {
    /** The extended metadata object provided to the constructor. */
    extended: any;
    /** The global extended metadata object provided to the constructor. */
    globalExtended: any;
    /** The number of bytes remaining to be written into the stream. */
    remain: number;
    /** The number of 512-byte blocks remaining to be written into the stream. */
    blockRemain: number;
    /** Whether this entry should be ignored. */
    ignore: boolean;
    /**
     * True if this represents metadata about the next entry, false if it
     * represents a filesystem object.
     */
    meta: boolean;
}

export interface CreateOptions {
    /**
     * A function that will get called with (code, message, data) for any
     * warnings encountered. (See "Warnings and Errors")
     */
    onwarn?(code: string, message: string, data: Buffer): void;

    /**
     * Treat warnings as crash-worthy errors. Default false.
     */
    strict?: boolean | undefined;

    /**
     * The current working directory for creating the archive. Defaults to process.cwd().
     */
    cwd?: string | undefined;

    /**
     * Alias for cwd.
     */
    C?: string | undefined;

    /**
     * Set to any truthy value to create a gzipped archive,
     * or an object with settings for zlib.Gzip()
     */
    gzip?: boolean | zlib.ZlibOptions | undefined;

    /**
     * Alias for gzip.
     */
    z?: boolean | zlib.ZlibOptions | undefined;

    /**
     * Set to any truthy value to create a brotli-compressed archive,
     * or an object with settings for zlib.BrotliCompress()
     */
    brotli?: boolean | zlib.BrotliOptions | undefined;

    /**
     * A function that gets called with (path, stat) for each entry being
     * added. Return true to add the entry to the archive, or false to omit it.
     */
    filter?(path: string, stat: fs.Stats): boolean;

    /**
     * Omit metadata that is system-specific: ctime, atime, uid, gid, uname,
     * gname, dev, ino, and nlink. Note that mtime is still included,
     * because this is necessary other time-based operations.
     */
    portable?: boolean | undefined;

    /**
     * Allow absolute paths. By default, / is stripped from absolute paths.
     */
    preservePaths?: boolean | undefined;

    /**
     * Alias for presevePaths.
     */
    P?: boolean | undefined;

    /**
     * The mode to set on the created file archive.
     */
    mode?: number | undefined;

    /**
     * Do not recursively archive the contents of directories.
     */
    noDirRecurse?: boolean | undefined;

    /**
     * Set to true to pack the targets of symbolic links. Without this
     * option, symbolic links are archived as such.
     */
    follow?: boolean | undefined;

    /**
     * Alias for follow.
     */
    L?: boolean | undefined;

    /**
     * Alias for follow.
     */
    h?: boolean | undefined;

    /**
     * Suppress pax extended headers. Note that this means that long paths and
     * linkpaths will be truncated, and large or negative numeric values
     * may be interpreted incorrectly.
     */
    noPax?: boolean | undefined;

    /**
     * Set to true to omit writing mtime values for entries. Note that this prevents using other mtime-based features
     * like `tar.update` or the `keepNewer` option with the resulting tar archive. [Alias: m, no-mtime]
     */
    noMtime?: boolean | undefined;
    m?: boolean | undefined;
    "no-mtime"?: boolean | undefined;

    /**
     * Set to a Date object to force a specific mtime for everything added to the archive. Overridden by noMtime.
     */
    mtime?: Date;

    /**
     * A path portion to prefix onto the entries in the archive.
     */
    prefix?: string | undefined;
}

export interface ExtractOptions {
    /**
     * A function that will get called with (code, message, data) for any
     * warnings encountered. (See "Warnings and Errors")
     */
    onwarn?(code: string, message: string, data: Buffer): void;

    /**
     * Treat warnings as crash-worthy errors. Default false.
     */
    strict?: boolean | undefined;

    /**
     * Extract files relative to the specified directory. Defaults to
     * process.cwd(). If provided, this must exist and must be a directory.
     */
    cwd?: string | undefined;

    /**
     * Alias for cwd.
     */
    C?: string | undefined;

    /**
     * A function that gets called with (path, stat) for each entry being
     * added. Return true to emit the entry from the archive, or false to skip it.
     */
    filter?(path: string, stat: FileStat): boolean;

    /**
     * Set to true to keep the existing file on disk if it's newer than
     * the file in the archive.
     */
    newer?: boolean | undefined;

    /**
     * Alias for newer.
     */
    "keep-newer"?: boolean | undefined;

    /**
     * Alias for newer.
     */
    "keep-newer-files"?: boolean | undefined;

    /**
     * Do not overwrite existing files. In particular, if a file appears more
     * than once in an archive, later copies will not overwrite earlier copies
     */
    keep?: boolean | undefined;

    /**
     * Alias for keep.
     */
    k?: boolean | undefined;

    /**
     * Alias for keep.
     */
    "keep-existing"?: boolean | undefined;

    /**
     * Allow absolute paths, paths containing .., and extracting
     * through symbolic links. By default, / is stripped from
     * absolute paths, .. paths are not extracted, and any file
     * whose location would be modified by a symbolic link is not
     * extracted.
     */
    preservePaths?: boolean | undefined;

    /**
     * Alias for presevePaths.
     */
    P?: boolean | undefined;

    /**
     * Unlink files before creating them. Without this option, tar overwrites
     * existing files, which preserves existing hardlinks. With this option,
     * existing hardlinks will be broken, as will any symlink that would
     * affect the location of an extracted file.
     */
    unlink?: boolean | undefined;

    /**
     * Remove the specified number of leading path elements. Pathnames with
     * fewer elements will be silently skipped. Note that the pathname
     * is edited after applying the filter, but before security checks.
     */
    strip?: number | undefined;

    /**
     * Alias for strip.
     */
    "strip-components"?: number | undefined;

    /**
     * Alias for strip.
     */
    stripComponents?: number | undefined;

    /**
     * If true, tar will set the uid and gid of extracted entries to the uid
     * and gid fields in the archive. This defaults to true when run as root,
     * and false otherwise. If false, then files and directories will be set
     * with the owner and group of the user running the process. This is
     * similar to -p in tar(1), but ACLs and other system-specific data is
     * never unpacked in this implementation, and modes
     * are set by default already.
     */
    preserveOwner?: boolean | undefined;

    /**
     * Alias for preserveOwner.
     */
    p?: boolean | undefined;

    /**
     * Set to a number to force ownership of all extracted files and folders,
     * and all implicitly created directories, to be owned by the specified
     * user id, regardless of the uid field in the archive. Cannot be used
     * along with preserveOwner. Requires also setting a gid option.
     */
    uid?: number | undefined;

    /**
     * Set to a number to force ownership of all extracted files and folders,
     * and all implicitly created directories, to be owned by the specified
     * group id, regardless of the gid field in the archive. Cannot be used
     * along with preserveOwner. Requires also setting a uid option
     */
    gid?: number | undefined;

    /**
     * Set to true to omit writing mtime value for extracted entries.
     * [Alias: m, no-mtime]
     */
    noMtime?: boolean | undefined;
    m?: boolean | undefined;
    "no-mtime"?: boolean | undefined;

    /**
     * Provide a function that takes an entry object, and returns a stream,
     * or any falsey value. If a stream is provided, then that stream's data
     * will be written instead of the contents of the archive entry. If a
     * falsey value is provided, then the entry is written to disk as normal.
     * (To exclude items from extraction, use the filter option described above.)
     */
    transform?(entry: ReadEntry): NodeJS.WritableStream | undefined | false | null;

    /**
     * A function that gets called with (entry) for each entry that passes the
     * filter.
     */
    onentry?(entry: ReadEntry): void;

    /**
     * Set to true to omit calling `fs.chmod()` to ensure that the extracted file
     * matches the entry mode. This also suppresses the call to `process.umask()`
     * to determine the default umask value, since tar will extract with whatever
     * mode is provided, and let the process `umask` apply normally.
     */
    noChmod?: boolean | undefined;

    // The following options are mostly internal, but can be modified in some
    // advanced use cases, such as re-using caches between runs.

    /**
     * The maximum buffer size for fs.read() operations (in bytes). Defaults to 16 MB.
     */
    maxReadSize?: number | undefined;

    /**
     * The maximum size of meta entries that is supported. Defaults to 1 MB.
     */
    maxMetaEntrySize?: number | undefined;
}

export interface ListOptions {
    /**
     * Treat warnings as crash-worthy errors. Default false.
     */
    strict?: boolean | undefined;

    /**
     * Extract files relative to the specified directory. Defaults to
     * process.cwd(). If provided, this must exist and must be a directory.
     */
    cwd?: string | undefined;

    /**
     * Alias for cwd.
     */
    C?: string | undefined;

    /**
     * A function that gets called with (path, stat) for each entry being
     * added. Return true to emit the entry from the archive, or false to skip it.
     */
    filter?(path: string, entry: FileStat): boolean;

    /**
     * A function that gets called with (entry) for each entry that passes the
     * filter. This is important for when both file and sync are set, because
     * it will be called synchronously.
     */
    onentry?(entry: ReadEntry): void;

    /**
     * The maximum buffer size for fs.read() operations. Defaults to 16 MB.
     */
    maxReadSize?: number | undefined;

    /**
     * By default, entry streams are resumed immediately after the call to
     * onentry. Set noResume: true to suppress this behavior. Note that by
     * opting into this, the stream will never complete until the entry
     * data is consumed.
     */
    noResume?: boolean | undefined;
}

export interface ReplaceOptions {
    /**
     * Required. Write the tarball archive to the specified filename.
     */
    file: string;

    /**
     * Act synchronously. If this is set, then any provided file will be
     * fully written after the call to tar.c.
     */
    sync?: boolean | undefined;

    /**
     * A function that will get called with (code, message, data) for any
     * warnings encountered. (See "Warnings and Errors")
     */
    onwarn?(code: string, message: string, data: Buffer): void;

    /**
     * Treat warnings as crash-worthy errors. Default false.
     */
    strict?: boolean | undefined;

    /**
     * Extract files relative to the specified directory. Defaults to
     * process.cwd(). If provided, this must exist and must be a directory.
     */
    cwd?: string | undefined;

    /**
     * Alias for cwd.
     */
    C?: string | undefined;

    /**
     * A path portion to prefix onto the entries in the archive.
     */
    prefix?: string | undefined;

    /**
     * A function that gets called with (path, stat) for each entry being
     * added. Return true to emit the entry from the archive, or false to skip it.
     */
    filter?(path: string, stat: fs.Stats): boolean;

    /**
     * Allow absolute paths. By default, / is stripped from absolute paths.
     */
    preservePaths?: boolean | undefined;

    /**
     * The maximum buffer size for fs.read() operations. Defaults to 16 MB.
     */
    maxReadSize?: number | undefined;

    /**
     * Do not recursively archive the contents of directories.
     */
    noDirRecurse?: boolean | undefined;

    /**
     * Set to true to pack the targets of symbolic links. Without this
     * option, symbolic links are archived as such.
     */
    follow?: boolean | undefined;

    /**
     * Alias for follow.
     */
    L?: boolean | undefined;

    /**
     * Alias for follow.
     */
    h?: boolean | undefined;

    /**
     * uppress pax extended headers. Note that this means that long paths and
     * linkpaths will be truncated, and large or negative numeric values
     * may be interpreted incorrectly.
     */
    noPax?: boolean | undefined;
}

export interface FileOptions {
    /**
     * Uses the given file as the input or output of this function.
     */
    file?: string | undefined;

    /**
     * Alias for file.
     */
    f?: string | undefined;
}

export type RequiredFileOptions =
    | {
        /**
         * Uses the given file as the input or output of this function.
         */
        file: string;
    }
    | {
        /**
         * Alias for file.
         */
        f: string;
    };

/**
 * Create a tarball archive. The fileList is an array of paths to add to the
 * tarball. Adding a directory also adds its children recursively. An entry in
 * fileList that starts with an @ symbol is a tar archive whose entries will
 * be added. To add a file that starts with @, prepend it with `./`.
 *
 * Archive data may be read from the returned stream.
 */
export function create(
    options: CreateOptions,
    fileList: readonly string[],
    callback?: (err?: Error) => void,
): stream.Readable;

/**
 * Create a tarball archive. The fileList is an array of paths to add to the
 * tarball. Adding a directory also adds its children recursively. An entry in
 * fileList that starts with an @ symbol is a tar archive whose entries will
 * be added. To add a file that starts with @, prepend it with `./`.
 */
export function create(options: CreateOptions & FileOptions, fileList: readonly string[]): Promise<void>;
export function create(options: CreateOptions & FileOptions & { sync: true }, fileList: readonly string[]): void;
export function create(
    options: CreateOptions & FileOptions,
    fileList: readonly string[],
    callback: (err?: Error) => void,
): void;

/**
 * Alias for create
 */
export const c: typeof create;

/**
 * Extract a tarball archive. The fileList is an array of paths to extract
 * from the tarball. If no paths are provided, then all the entries are
 * extracted. If the archive is gzipped, then tar will detect this and unzip
 * it. Note that all directories that are created will be forced to be
 * writable, readable, and listable by their owner, to avoid cases where a
 * directory prevents extraction of child entries by virtue of its mode. Most
 * extraction errors will cause a warn event to be emitted. If the cwd is
 * missing, or not a directory, then the extraction will fail completely.
 *
 * Archive data should be written to the returned stream.
 */
export function extract(
    options: ExtractOptions,
    fileList?: readonly string[],
    callback?: (err?: Error) => void,
): stream.Writable;

/**
 * Extract a tarball archive. The fileList is an array of paths to extract
 * from the tarball. If no paths are provided, then all the entries are
 * extracted. If the archive is gzipped, then tar will detect this and unzip
 * it. Note that all directories that are created will be forced to be
 * writable, readable, and listable by their owner, to avoid cases where a
 * directory prevents extraction of child entries by virtue of its mode. Most
 * extraction errors will cause a warn event to be emitted. If the cwd is
 * missing, or not a directory, then the extraction will fail completely.
 */
export function extract(options: ExtractOptions & FileOptions, fileList?: readonly string[]): Promise<void>;
export function extract(options: ExtractOptions & FileOptions & { sync: true }, fileList?: readonly string[]): void;
export function extract(
    options: ExtractOptions & FileOptions,
    fileList: readonly string[] | undefined,
    callback: (err?: Error) => void,
): void;

/**
 * Alias for extract
 */
export const x: typeof extract;

/**
 * List the contents of a tarball archive. The fileList is an array of paths
 * to list from the tarball. If no paths are provided, then all the entries
 * are listed. If the archive is gzipped, then tar will detect this and unzip
 * it.
 */
export function list(options: ListOptions & RequiredFileOptions, fileList?: readonly string[]): Promise<void>;
export function list(options: ListOptions & RequiredFileOptions & { sync: true }, fileList?: readonly string[]): void;
export function list(callback?: (err?: Error) => void): Parse;
export function list(optionsOrFileList: ListOptions | readonly string[], callback?: (err?: Error) => void): Parse;
export function list(options: ListOptions, fileList: readonly string[], callback?: (err?: Error) => void): Parse;

/**
 * Alias for list
 */
export const t: typeof list;

/**
 * Add files to an existing archive. Because later entries override earlier
 * entries, this effectively replaces any existing entries. The fileList is an
 * array of paths to add to the tarball. Adding a directory also adds its
 * children recursively. An entry in fileList that starts with an @ symbol is
 * a tar archive whose entries will be added. To add a file that
 * starts with @, prepend it with ./.
 */
export function replace(options: ReplaceOptions, fileList?: readonly string[]): Promise<void>;
export function replace(
    options: ReplaceOptions,
    fileList: readonly string[] | undefined,
    callback: (err?: Error) => void,
): Promise<void>;

/**
 * Alias for replace
 */
export const r: typeof replace;

/**
 * Add files to an archive if they are newer than the entry already in the
 * tarball archive. The fileList is an array of paths to add to the tarball.
 * Adding a directory also adds its children recursively. An entry in fileList
 * that starts with an @ symbol is a tar archive whose entries will be added.
 * To add a file that starts with @, prepend it with ./.
 */
export function update(options: ReplaceOptions, fileList?: readonly string[]): Promise<void>;
export function update(
    options: ReplaceOptions,
    fileList: readonly string[] | undefined,
    callback: (err?: Error) => void,
): Promise<void>;

/**
 * Alias for update
 */
export const u: typeof update;

export {};
=== END FILE ===
=== START FILE: ./node_modules/@types/normalize-package-data/index.d.ts ===
export = normalize;

declare function normalize(data: normalize.Input, warn?: normalize.WarnFn, strict?: boolean): void;
declare function normalize(data: normalize.Input, strict?: boolean): void;

declare namespace normalize {
    type WarnFn = (msg: string) => void;
    interface Input {
        [k: string]: any;
    }

    interface Person {
        name?: string | undefined;
        email?: string | undefined;
        url?: string | undefined;
    }

    interface Package {
        [k: string]: any;
        name: string;
        version: string;
        files?: string[] | undefined;
        bin?: { [k: string]: string } | undefined;
        man?: string[] | undefined;
        keywords?: string[] | undefined;
        author?: Person | undefined;
        maintainers?: Person[] | undefined;
        contributors?: Person[] | undefined;
        bundleDependencies?: { [name: string]: string } | undefined;
        dependencies?: { [name: string]: string } | undefined;
        devDependencies?: { [name: string]: string } | undefined;
        optionalDependencies?: { [name: string]: string } | undefined;
        description?: string | undefined;
        engines?: { [type: string]: string } | undefined;
        license?: string | undefined;
        repository?: { type: string; url: string } | undefined;
        bugs?: { url: string; email?: string | undefined } | { url?: string | undefined; email: string } | undefined;
        homepage?: string | undefined;
        scripts?: { [k: string]: string } | undefined;
        readme: string;
        _id: string;
    }
}
=== END FILE ===
=== START FILE: ./node_modules/@types/markdown-it/dist/markdown-it.min.d.ts ===
import MarkdownIt = require("./index.cjs.js");

export as namespace markdownit;

export = MarkdownIt;
=== END FILE ===
=== START FILE: ./node_modules/@types/markdown-it/dist/index.cjs.d.ts ===
import LinkifyIt = require("linkify-it");
import mdurl = require("mdurl");
// import ucmicro = require("uc.micro");

// lib/token.mjs

declare class Token {
    /**
     * Create new token and fill passed properties.
     */
    constructor(type: string, tag: string, nesting: MarkdownIt.Token.Nesting);

    /**
     * Type of the token, e.g. "paragraph_open"
     */
    type: string;

    /**
     * HTML tag name, e.g. "p"
     */
    tag: string;

    /**
     * HTML attributes. Format: `[ [ name1, value1 ], [ name2, value2 ] ]`
     */
    attrs: Array<[string, string]> | null;

    /**
     * Source map info. Format: `[ line_begin, line_end ]`
     */
    map: [number, number] | null;

    /**
     * Level change (number in {-1, 0, 1} set), where:
     *
     * -  `1` means the tag is opening
     * -  `0` means the tag is self-closing
     * - `-1` means the tag is closing
     */
    nesting: MarkdownIt.Token.Nesting;

    /**
     * Nesting level, the same as `state.level`
     */
    level: number;

    /**
     * An array of child nodes (inline and img tokens)
     */
    children: Token[] | null;

    /**
     * In a case of self-closing tag (code, html, fence, etc.),
     * it has contents of this tag.
     */
    content: string;

    /**
     * '*' or '_' for emphasis, fence string for fence, etc.
     */
    markup: string;

    /**
     * - Info string for "fence" tokens
     * - The value "auto" for autolink "link_open" and "link_close" tokens
     * - The string value of the item marker for ordered-list "list_item_open" tokens
     */
    info: string;

    /**
     * A place for plugins to store an arbitrary data
     */
    meta: any;

    /**
     * True for block-level tokens, false for inline tokens.
     * Used in renderer to calculate line breaks
     */
    block: boolean;

    /**
     * If it's true, ignore this element when rendering. Used for tight lists
     * to hide paragraphs.
     */
    hidden: boolean;

    /**
     * Search attribute index by name.
     */
    attrIndex(name: string): number;

    /**
     * Add `[ name, value ]` attribute to list. Init attrs if necessary
     */
    attrPush(attrData: [string, string]): void;

    /**
     * Set `name` attribute to `value`. Override old value if exists.
     */
    attrSet(name: string, value: string): void;

    /**
     * Get the value of attribute `name`, or null if it does not exist.
     */
    attrGet(name: string): string | null;

    /**
     * Join value to existing attribute via space. Or create new attribute if not
     * exists. Useful to operate with token classes.
     */
    attrJoin(name: string, value: string): void;
}

type Token_ = Token;

// lib/renderer.mjs

declare class Renderer {
    /**
     * Creates new {@link Renderer} instance and fill {@link Renderer#rules} with defaults.
     */
    constructor();

    /**
     * Contains render rules for tokens. Can be updated and extended.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')();
     *
     * md.renderer.rules.strong_open  = function () { return '<b>'; };
     * md.renderer.rules.strong_close = function () { return '</b>'; };
     *
     * var result = md.renderInline(...);
     * ```
     *
     * Each rule is called as independent static function with fixed signature:
     *
     * ```javascript
     * function my_token_render(tokens, idx, options, env, renderer) {
     *   // ...
     *   return renderedHTML;
     * }
     * ```
     *
     * @see https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs
     */
    rules: MarkdownIt.Renderer.RenderRuleRecord;

    /**
     * Render token attributes to string.
     */
    renderAttrs(token: Token): string;

    /**
     * Default token renderer. Can be overriden by custom function
     * in {@link Renderer#rules}.
     *
     * @param tokens list of tokens
     * @param idx token index to render
     * @param options params of parser instance
     */
    renderToken(tokens: Token[], idx: number, options: MarkdownIt.Options): string;

    /**
     * The same as {@link Renderer.render}, but for single token of `inline` type.
     *
     * @param tokens list of block tokens to render
     * @param options params of parser instance
     * @param env additional data from parsed input (references, for example)
     */
    renderInline(tokens: Token[], options: MarkdownIt.Options, env: any): string;

    /**
     * Special kludge for image `alt` attributes to conform CommonMark spec.
     * Don't try to use it! Spec requires to show `alt` content with stripped markup,
     * instead of simple escaping.
     *
     * @param tokens list of block tokens to render
     * @param options params of parser instance
     * @param env additional data from parsed input (references, for example)
     */
    renderInlineAsText(tokens: Token[], options: MarkdownIt.Options, env: any): string;

    /**
     * Takes token stream and generates HTML. Probably, you will never need to call
     * this method directly.
     *
     * @param tokens list of block tokens to render
     * @param options params of parser instance
     * @param env additional data from parsed input (references, for example)
     */
    render(tokens: Token[], options: MarkdownIt.Options, env: any): string;
}

type Renderer_ = Renderer;

// lib/ruler.mjs

/**
 * Helper class, used by {@link MarkdownIt#core}, {@link MarkdownIt#block} and
 * {@link MarkdownIt#inline} to manage sequences of functions (rules):
 *
 * - keep rules in defined order
 * - assign the name to each rule
 * - enable/disable rules
 * - add/replace rules
 * - allow assign rules to additional named chains (in the same)
 * - caching lists of active rules
 *
 * You will not need use this class directly until write plugins. For simple
 * rules control use {@link MarkdownIt.disable}, {@link MarkdownIt.enable} and
 * {@link MarkdownIt.use}.
 */
declare class Ruler<T> {
    constructor();

    /**
     * Replace rule by name with new function & options. Throws error if name not
     * found.
     *
     * ##### Example
     *
     * Replace existing typographer replacement rule with new one:
     *
     * ```javascript
     * var md = require('markdown-it')();
     *
     * md.core.ruler.at('replacements', function replace(state) {
     *   //...
     * });
     * ```
     *
     * @param name rule name to replace.
     * @param fn new rule function.
     * @param options new rule options (not mandatory).
     */
    at(name: string, fn: T, options?: MarkdownIt.Ruler.RuleOptions): void;

    /**
     * Add new rule to chain before one with given name.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')();
     *
     * md.block.ruler.before('paragraph', 'my_rule', function replace(state) {
     *   //...
     * });
     * ```
     *
     * @see {@link Ruler.after}, {@link Ruler.push}
     *
     * @param beforeName new rule will be added before this one.
     * @param ruleName name of added rule.
     * @param fn rule function.
     * @param options rule options (not mandatory).
     */
    before(beforeName: string, ruleName: string, fn: T, options?: MarkdownIt.Ruler.RuleOptions): void;

    /**
     * Add new rule to chain after one with given name.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')();
     *
     * md.inline.ruler.after('text', 'my_rule', function replace(state) {
     *   //...
     * });
     * ```
     *
     * @see {@link Ruler.before}, {@link Ruler.push}
     *
     * @param afterName new rule will be added after this one.
     * @param ruleName name of added rule.
     * @param fn rule function.
     * @param options rule options (not mandatory).
     */
    after(afterName: string, ruleName: string, fn: T, options?: MarkdownIt.Ruler.RuleOptions): void;

    /**
     * Push new rule to the end of chain.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')();
     *
     * md.core.ruler.push('my_rule', function replace(state) {
     *   //...
     * });
     * ```
     *
     * @see {@link Ruler.before}, {@link Ruler.after}
     *
     * @param ruleName name of added rule.
     * @param fn rule function.
     * @param options rule options (not mandatory).
     */
    push(ruleName: string, fn: T, options?: MarkdownIt.Ruler.RuleOptions): void;

    /**
     * Enable rules with given names. If any rule name not found - throw Error.
     * Errors can be disabled by second param.
     *
     * Returns list of found rule names (if no exception happened).
     *
     * @see {@link Ruler.disable}, {@link Ruler.enableOnly}
     *
     * @param list list of rule names to enable.
     * @param ignoreInvalid set `true` to ignore errors when rule not found.
     */
    enable(list: string | string[], ignoreInvalid?: boolean): string[];

    /**
     * Enable rules with given names, and disable everything else. If any rule name
     * not found - throw Error. Errors can be disabled by second param.
     *
     * @see {@link Ruler.disable}, {@link Ruler.enable}
     *
     * @param list list of rule names to enable (whitelist).
     * @param ignoreInvalid set `true` to ignore errors when rule not found.
     */
    enableOnly(list: string | string[], ignoreInvalid?: boolean): void;

    /**
     * Disable rules with given names. If any rule name not found - throw Error.
     * Errors can be disabled by second param.
     *
     * Returns list of found rule names (if no exception happened).
     *
     * @see {@link Ruler.enable}, {@link Ruler.enableOnly}
     *
     * @param list list of rule names to disable.
     * @param ignoreInvalid set `true` to ignore errors when rule not found.
     */
    disable(list: string | string[], ignoreInvalid?: boolean): string[];

    /**
     * Return array of active functions (rules) for given chain name. It analyzes
     * rules configuration, compiles caches if not exists and returns result.
     *
     * Default chain name is `''` (empty string). It can't be skipped. That's
     * done intentionally, to keep signature monomorphic for high speed.
     */
    getRules(chainName: string): T[];
}

type Ruler_<T> = Ruler<T>;

// lib/rules_core/state_core.mjs

declare class StateCore {
    constructor(src: string, md: MarkdownIt, env: any);

    src: string;
    env: any;
    tokens: Token[];
    inlineMode: boolean;

    /**
     * link to parser instance
     */
    md: MarkdownIt;

    Token: typeof Token;
}

type StateCore_ = StateCore;

// lib/rules_block/state_block.mjs

declare class StateBlock {
    constructor(src: string, md: MarkdownIt, env: any, tokens: Token[]);

    src: string;

    /**
     * link to parser instance
     */
    md: MarkdownIt;

    env: any;

    //
    // Internal state vartiables
    //

    tokens: Token[];

    /**
     * line begin offsets for fast jumps
     */
    bMarks: number[];
    /**
     * line end offsets for fast jumps
     */
    eMarks: number[];
    /**
     * offsets of the first non-space characters (tabs not expanded)
     */
    tShift: number[];
    /**
     * indents for each line (tabs expanded)
     */
    sCount: number[];

    /**
     * An amount of virtual spaces (tabs expanded) between beginning
     * of each line (bMarks) and real beginning of that line.
     *
     * It exists only as a hack because blockquotes override bMarks
     * losing information in the process.
     *
     * It's used only when expanding tabs, you can think about it as
     * an initial tab length, e.g. bsCount=21 applied to string `\t123`
     * means first tab should be expanded to 4-21%4 === 3 spaces.
     */
    bsCount: number[];

    // block parser variables

    /**
     * required block content indent (for example, if we are
     * inside a list, it would be positioned after list marker)
     */
    blkIndent: number;
    /**
     * line index in src
     */
    line: number;
    /**
     * lines count
     */
    lineMax: number;
    /**
     * loose/tight mode for lists
     */
    tight: boolean;
    /**
     * indent of the current dd block (-1 if there isn't any)
     */
    ddIndent: number;
    /**
     * indent of the current list block (-1 if there isn't any)
     */
    listIndent: number;

    /**
     * used in lists to determine if they interrupt a paragraph
     */
    parentType: MarkdownIt.StateBlock.ParentType;

    level: number;

    /**
     * Push new token to "stream".
     */
    push(type: string, tag: string, nesting: MarkdownIt.Token.Nesting): Token;

    isEmpty(line: number): boolean;

    skipEmptyLines(from: number): number;

    /**
     * Skip spaces from given position.
     */
    skipSpaces(pos: number): number;

    /**
     * Skip spaces from given position in reverse.
     */
    skipSpacesBack(pos: number, min: number): number;

    /**
     * Skip char codes from given position
     */
    skipChars(pos: number, code: number): number;

    /**
     * Skip char codes reverse from given position - 1
     */
    skipCharsBack(pos: number, code: number, min: number): number;

    /**
     * cut lines range from source.
     */
    getLines(begin: number, end: number, indent: number, keepLastLF: boolean): string;

    Token: typeof Token;
}

type StateBlock_ = StateBlock;

// lib/rules_inline/state_inline.mjs

declare class StateInline {
    constructor(src: string, md: MarkdownIt, env: any, outTokens: Token[]);

    src: string;
    env: any;
    md: MarkdownIt;
    tokens: Token[];
    tokens_meta: Array<MarkdownIt.StateInline.TokenMeta | null>;

    pos: number;
    posMax: number;
    level: number;
    pending: string;
    pendingLevel: number;

    /**
     * Stores { start: end } pairs. Useful for backtrack
     * optimization of pairs parse (emphasis, strikes).
     */
    cache: any;

    /**
     * List of emphasis-like delimiters for current tag
     */
    delimiters: MarkdownIt.StateInline.Delimiter[];

    // Stack of delimiter lists for upper level tags
    // _prev_delimiters: StateInline.Delimiter[][];

    /**
     * Flush pending text
     */
    pushPending(): Token;

    /**
     * Push new token to "stream".
     * If pending text exists - flush it as text token
     */
    push(type: string, tag: string, nesting: MarkdownIt.Token.Nesting): Token;

    /**
     * Scan a sequence of emphasis-like markers, and determine whether
     * it can start an emphasis sequence or end an emphasis sequence.
     *
     * @param start position to scan from (it should point at a valid marker)
     * @param canSplitWord determine if these markers can be found inside a word
     */
    scanDelims(start: number, canSplitWord: boolean): MarkdownIt.StateInline.Scanned;

    Token: typeof Token;
}

type StateInline_ = StateInline;

// lib/parser_core.mjs

declare class Core {
    /**
     * {@link Ruler} instance. Keep configuration of core rules.
     */
    ruler: Ruler<MarkdownIt.Core.RuleCore>;

    /**
     * Executes core chain rules.
     */
    process(state: StateCore): void;

    State: typeof StateCore;
}

type Core_ = Core;

// lib/parser_block.mjs

declare class ParserBlock {
    /**
     * {@link Ruler} instance. Keep configuration of block rules.
     */
    ruler: Ruler<MarkdownIt.ParserBlock.RuleBlock>;

    /**
     * Generate tokens for input range
     */
    tokenize(state: StateBlock, startLine: number, endLine: number): void;

    /**
     * Process input string and push block tokens into `outTokens`
     */
    parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;

    State: typeof StateBlock;
}

type ParserBlock_ = ParserBlock;

// lib/parser_inline.mjs

declare class ParserInline {
    /**
     * {@link Ruler} instance. Keep configuration of inline rules.
     */
    ruler: Ruler<MarkdownIt.ParserInline.RuleInline>;

    /**
     * {@link Ruler} instance. Second ruler used for post-processing
     * (e.g. in emphasis-like rules).
     */
    ruler2: Ruler<MarkdownIt.ParserInline.RuleInline2>;

    /**
     * Skip single token by running all rules in validation mode;
     * returns `true` if any rule reported success
     */
    skipToken(state: StateInline): void;

    /**
     * Generate tokens for input range
     */
    tokenize(state: StateInline): void;

    /**
     * Process input string and push inline tokens into `outTokens`
     */
    parse(str: string, md: MarkdownIt, env: any, outTokens: Token[]): void;

    State: typeof StateInline;
}

type ParserInline_ = ParserInline;

declare namespace MarkdownIt {
    // lib/common/utils.mjs

    interface Utils {
        lib: {
            mdurl: typeof mdurl;
            ucmicro: any;
        };

        /**
         * Merge objects
         */
        assign(obj: any, ...from: any[]): any;

        isString(obj: any): obj is string;

        has(obj: any, key: keyof any): boolean;

        unescapeMd(str: string): string;

        unescapeAll(str: string): string;

        isValidEntityCode(c: number): boolean;

        fromCodePoint(c: number): string;

        escapeHtml(str: string): string;

        /**
         * Remove element from array and put another array at those position.
         * Useful for some operations with tokens
         */
        arrayReplaceAt<T>(src: T[], pos: number, newElements: T[]): T[];

        isSpace(code: number): boolean;

        /**
         * Zs (unicode class) || [\t\f\v\r\n]
         */
        isWhiteSpace(code: number): boolean;

        /**
         * Markdown ASCII punctuation characters.
         *
         * !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /, :, ;, <, =, >, ?, @, [, \, ], ^, _, `, {, |, }, or ~
         *
         * Don't confuse with unicode punctuation !!! It lacks some chars in ascii range.
         *
         * @see http://spec.commonmark.org/0.15/#ascii-punctuation-character
         */
        isMdAsciiPunct(code: number): boolean;

        /**
         * Currently without astral characters support.
         */
        isPunctChar(ch: string): boolean;

        escapeRE(str: string): string;

        /**
         * Helper to unify [reference labels].
         */
        normalizeReference(str: string): string;
    }

    // lib/helpers/index.mjs

    interface ParseLinkDestinationResult {
        ok: boolean;
        pos: number;
        str: string;
    }

    interface ParseLinkTitleResult {
        /**
         * if `true`, this is a valid link title
         */
        ok: boolean;
        /**
         * if `true`, this link can be continued on the next line
         */
        can_continue: boolean;
        /**
         * if `ok`, it's the position of the first character after the closing marker
         */
        pos: number;
        /**
         * if `ok`, it's the unescaped title
         */
        str: string;
        /**
         * expected closing marker character code
         */
        marker: number;
    }

    interface Helpers {
        // lib/helpers/parse_link_label.mjs

        parseLinkLabel(state: StateInline, start: number, disableNested?: boolean): number;

        // lib/helpers/parse_link_destination.mjs

        parseLinkDestination(str: string, start: number, max: number): ParseLinkDestinationResult;

        // lib/helpers/parse_link_title.mjs

        parseLinkTitle(
            str: string,
            start: number,
            max: number,
            prev_state?: ParseLinkTitleResult,
        ): ParseLinkTitleResult;
    }

    /**
     * MarkdownIt provides named presets as a convenience to quickly
     * enable/disable active syntax rules and options for common use cases.
     *
     * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) -
     *   configures parser to strict [CommonMark](http://commonmark.org/) mode.
     * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) -
     *   similar to GFM, used when no preset name given. Enables all available rules,
     *   but still without html, typographer & autolinker.
     * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) -
     *   all rules disabled. Useful to quickly setup your config via `.enable()`.
     *   For example, when you need only `bold` and `italic` markup and nothing else.
     */
    type PresetName = "default" | "zero" | "commonmark";

    interface Options {
        /**
         * Set `true` to enable HTML tags in source. Be careful!
         * That's not safe! You may need external sanitizer to protect output from XSS.
         * It's better to extend features via plugins, instead of enabling HTML.
         * @default false
         */
        html?: boolean | undefined;

        /**
         * Set `true` to add '/' when closing single tags
         * (`<br />`). This is needed only for full CommonMark compatibility. In real
         * world you will need HTML output.
         * @default false
         */
        xhtmlOut?: boolean | undefined;

        /**
         * Set `true` to convert `\n` in paragraphs into `<br>`.
         * @default false
         */
        breaks?: boolean | undefined;

        /**
         * CSS language class prefix for fenced blocks.
         * Can be useful for external highlighters.
         * @default 'language-'
         */
        langPrefix?: string | undefined;

        /**
         * Set `true` to autoconvert URL-like text to links.
         * @default false
         */
        linkify?: boolean | undefined;

        /**
         * Set `true` to enable [some language-neutral replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) +
         * quotes beautification (smartquotes).
         * @default false
         */
        typographer?: boolean | undefined;

        /**
         * Double + single quotes replacement
         * pairs, when typographer enabled and smartquotes on. For example, you can
         * use `'«»„“'` for Russian, `'„“‚‘'` for German, and
         * `['«\xA0', '\xA0»', '‹\xA0', '\xA0›']` for French (including nbsp).
         * @default '“”‘’'
         */
        quotes?: string | string[];

        /**
         * Highlighter function for fenced code blocks.
         * Highlighter `function (str, lang, attrs)` should return escaped HTML. It can
         * also return empty string if the source was not changed and should be escaped
         * externally. If result starts with <pre... internal wrapper is skipped.
         * @default null
         */
        highlight?: ((str: string, lang: string, attrs: string) => string) | null | undefined;
    }

    // lib/token.mjs

    type Token = Token_;
    namespace Token {
        type Nesting = 1 | 0 | -1;
    }

    // lib/renderer.mjs

    type Renderer = Renderer_;
    namespace Renderer {
        type RenderRule = (tokens: Token[], idx: number, options: Options, env: any, self: Renderer) => string;

        interface RenderRuleRecord {
            [type: string]: RenderRule | undefined;
            code_inline?: RenderRule | undefined;
            code_block?: RenderRule | undefined;
            fence?: RenderRule | undefined;
            image?: RenderRule | undefined;
            hardbreak?: RenderRule | undefined;
            softbreak?: RenderRule | undefined;
            text?: RenderRule | undefined;
            html_block?: RenderRule | undefined;
            html_inline?: RenderRule | undefined;
        }
    }

    // lib/ruler.mjs

    type Ruler<T> = Ruler_<T>;
    namespace Ruler {
        interface RuleOptions {
            /**
             * array with names of "alternate" chains.
             */
            alt: string[];
        }
    }

    // lib/rules_core/state_core.mjs

    type StateCore = StateCore_;

    // lib/rules_block/state_block.mjs

    type StateBlock = StateBlock_;
    namespace StateBlock {
        type ParentType = "blockquote" | "list" | "root" | "paragraph" | "reference";
    }

    // lib/rules_inline/state_inline.mjs

    type StateInline = StateInline_;
    namespace StateInline {
        interface Scanned {
            can_open: boolean;
            can_close: boolean;
            length: number;
        }

        interface Delimiter {
            marker: number;
            length: number;
            token: number;
            end: number;
            open: boolean;
            close: boolean;
        }

        interface TokenMeta {
            delimiters: Delimiter[];
        }
    }

    // lib/parser_core.mjs

    type Core = Core_;
    namespace Core {
        type RuleCore = (state: StateCore) => void;
    }

    // lib/parser_block.mjs

    type ParserBlock = ParserBlock_;
    namespace ParserBlock {
        type RuleBlock = (state: StateBlock, startLine: number, endLine: number, silent: boolean) => boolean;
    }

    // lib/parser_inline.mjs

    type ParserInline = ParserInline_;
    namespace ParserInline {
        type RuleInline = (state: StateInline, silent: boolean) => boolean;
        type RuleInline2 = (state: StateInline) => boolean;
    }

    type PluginSimple = (md: MarkdownIt) => void;
    type PluginWithOptions<T = any> = (md: MarkdownIt, options?: T) => void;
    type PluginWithParams = (md: MarkdownIt, ...params: any[]) => void;
}

interface MarkdownItConstructor {
    new(): MarkdownIt;
    new(presetName: MarkdownIt.PresetName, options?: MarkdownIt.Options): MarkdownIt;
    new(options: MarkdownIt.Options): MarkdownIt;
    (): MarkdownIt;
    (presetName: MarkdownIt.PresetName, options?: MarkdownIt.Options): MarkdownIt;
    (options: MarkdownIt.Options): MarkdownIt;
}

interface MarkdownIt {
    /**
     * Instance of {@link ParserInline}. You may need it to add new rules when
     * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
     * {@link MarkdownIt.enable}.
     */
    readonly inline: ParserInline;

    /**
     * Instance of {@link ParserBlock}. You may need it to add new rules when
     * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
     * {@link MarkdownIt.enable}.
     */
    readonly block: ParserBlock;

    /**
     * Instance of {@link Core} chain executor. You may need it to add new rules when
     * writing plugins. For simple rules control use {@link MarkdownIt.disable} and
     * {@link MarkdownIt.enable}.
     */
    readonly core: Core;

    /**
     * Instance of {@link Renderer}. Use it to modify output look. Or to add rendering
     * rules for new token types, generated by plugins.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')();
     *
     * function myToken(tokens, idx, options, env, self) {
     *   //...
     *   return result;
     * };
     *
     * md.renderer.rules['my_token'] = myToken
     * ```
     *
     * See {@link Renderer} docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js).
     */
    readonly renderer: Renderer;

    /**
     * [linkify-it](https://github.com/markdown-it/linkify-it) instance.
     * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js)
     * rule.
     */
    readonly linkify: LinkifyIt;

    /**
     * Link validation function. CommonMark allows too much in links. By default
     * we disable `javascript:`, `vbscript:`, `file:` schemas, and almost all `data:...` schemas
     * except some embedded image types.
     *
     * You can change this behaviour:
     *
     * ```javascript
     * var md = require('markdown-it')();
     * // enable everything
     * md.validateLink = function () { return true; }
     * ```
     */
    validateLink(url: string): boolean;

    /**
     * Function used to encode link url to a machine-readable format,
     * which includes url-encoding, punycode, etc.
     */
    normalizeLink(url: string): string;

    /**
     * Function used to decode link url to a human-readable format`
     */
    normalizeLinkText(url: string): string;

    readonly utils: MarkdownIt.Utils;

    readonly helpers: MarkdownIt.Helpers;

    readonly options: MarkdownIt.Options;

    /**
     * *chainable*
     *
     * Set parser options (in the same format as in constructor). Probably, you
     * will never need it, but you can change options after constructor call.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')()
     *             .set({ html: true, breaks: true })
     *             .set({ typographer: true });
     * ```
     *
     * __Note:__ To achieve the best possible performance, don't modify a
     * `markdown-it` instance options on the fly. If you need multiple configurations
     * it's best to create multiple instances and initialize each with separate
     * config.
     */
    set(options: MarkdownIt.Options): this;

    /**
     * *chainable*, *internal*
     *
     * Batch load of all options and compenent settings. This is internal method,
     * and you probably will not need it. But if you with - see available presets
     * and data structure [here](https://github.com/markdown-it/markdown-it/tree/master/lib/presets)
     *
     * We strongly recommend to use presets instead of direct config loads. That
     * will give better compatibility with next versions.
     */
    configure(presets: MarkdownIt.PresetName): this;

    /**
     * *chainable*
     *
     * Enable list or rules. It will automatically find appropriate components,
     * containing rules with given names. If rule not found, and `ignoreInvalid`
     * not set - throws exception.
     *
     * ##### Example
     *
     * ```javascript
     * var md = require('markdown-it')()
     *             .enable(['sub', 'sup'])
     *             .disable('smartquotes');
     * ```
     *
     * @param list rule name or list of rule names to enable
     * @param ignoreInvalid set `true` to ignore errors when rule not found.
     */
    enable(list: string | string[], ignoreInvalid?: boolean): this;

    /**
     * *chainable*
     *
     * The same as {@link MarkdownIt.enable}, but turn specified rules off.
     *
     * @param list rule name or list of rule names to disable.
     * @param ignoreInvalid set `true` to ignore errors when rule not found.
     */
    disable(list: string | string[], ignoreInvalid?: boolean): this;

    /**
     * *chainable*
     *
     * Load specified plugin with given params into current parser instance.
     * It's just a sugar to call `plugin(md, params)` with curring.
     *
     * ##### Example
     *
     * ```javascript
     * var iterator = require('markdown-it-for-inline');
     * var md = require('markdown-it')()
     *             .use(iterator, 'foo_replace', 'text', function (tokens, idx) {
     *               tokens[idx].content = tokens[idx].content.replace(/foo/g, 'bar');
     *             });
     * ```
     */
    use(plugin: MarkdownIt.PluginSimple): this;
    use<T = any>(plugin: MarkdownIt.PluginWithOptions<T>, options?: T): this;
    use(plugin: MarkdownIt.PluginWithParams, ...params: any[]): this;

    /**
     * *internal*
     *
     * Parse input string and returns list of block tokens (special token type
     * "inline" will contain list of inline tokens). You should not call this
     * method directly, until you write custom renderer (for example, to produce
     * AST).
     *
     * `env` is used to pass data between "distributed" rules and return additional
     * metadata like reference info, needed for the renderer. It also can be used to
     * inject data in specific cases. Usually, you will be ok to pass `{}`,
     * and then pass updated object to renderer.
     *
     * @param src source string
     * @param env environment sandbox
     */
    parse(src: string, env: any): Token[];

    /**
     * Render markdown string into html. It does all magic for you :).
     *
     * `env` can be used to inject additional metadata (`{}` by default).
     * But you will not need it with high probability. See also comment
     * in {@link MarkdownIt.parse}.
     *
     * @param src source string
     * @param env environment sandbox
     */
    render(src: string, env?: any): string;

    /**
     * *internal*
     *
     * The same as {@link MarkdownIt.parse} but skip all block rules. It returns the
     * block tokens list with the single `inline` element, containing parsed inline
     * tokens in `children` property. Also updates `env` object.
     *
     * @param src source string
     * @param env environment sandbox
     */
    parseInline(src: string, env: any): Token[];

    /**
     * Similar to {@link MarkdownIt.render} but for single paragraph content. Result
     * will NOT be wrapped into `<p>` tags.
     *
     * @param src source string
     * @param env environment sandbox
     */
    renderInline(src: string, env?: any): string;
}

/**
 * Main parser/renderer class.
 *
 * ##### Usage
 *
 * ```javascript
 * // node.js, "classic" way:
 * var MarkdownIt = require('markdown-it'),
 *     md = new MarkdownIt();
 * var result = md.render('# markdown-it rulezz!');
 *
 * // node.js, the same, but with sugar:
 * var md = require('markdown-it')();
 * var result = md.render('# markdown-it rulezz!');
 *
 * // browser without AMD, added to "window" on script load
 * // Note, there are no dash.
 * var md = window.markdownit();
 * var result = md.render('# markdown-it rulezz!');
 * ```
 *
 * Single line rendering, without paragraph wrap:
 *
 * ```javascript
 * var md = require('markdown-it')();
 * var result = md.renderInline('__markdown-it__ rulezz!');
 * ```
 *
 * ##### Example
 *
 * ```javascript
 * // commonmark mode
 * var md = require('markdown-it')('commonmark');
 *
 * // default mode
 * var md = require('markdown-it')();
 *
 * // enable everything
 * var md = require('markdown-it')({
 *   html: true,
 *   linkify: true,
 *   typographer: true
 * });
 * ```
 *
 * ##### Syntax highlighting
 *
 * ```js
 * var hljs = require('highlight.js') // https://highlightjs.org/
 *
 * var md = require('markdown-it')({
 *   highlight: function (str, lang) {
 *     if (lang && hljs.getLanguage(lang)) {
 *       try {
 *         return hljs.highlight(lang, str, true).value;
 *       } catch (__) {}
 *     }
 *
 *     return ''; // use external default escaping
 *   }
 * });
 * ```
 *
 * Or with full wrapper override (if you need assign class to `<pre>`):
 *
 * ```javascript
 * var hljs = require('highlight.js') // https://highlightjs.org/
 *
 * // Actual default values
 * var md = require('markdown-it')({
 *   highlight: function (str, lang) {
 *     if (lang && hljs.getLanguage(lang)) {
 *       try {
 *         return '<pre class="hljs"><code>' +
 *                hljs.highlight(lang, str, true).value +
 *                '</code></pre>';
 *       } catch (__) {}
 *     }
 *
 *     return '<pre class="hljs"><code>' + md.utils.escapeHtml(str) + '</code></pre>';
 *   }
 * });
 * ```
 */
declare const MarkdownIt: MarkdownItConstructor;

export = MarkdownIt;
=== END FILE ===
=== START FILE: ./node_modules/@types/markdown-it/dist/markdown-it.d.ts ===
import MarkdownIt = require("./index.cjs.js");

export as namespace markdownit;

export = MarkdownIt;
=== END FILE ===
=== START FILE: ./node_modules/@types/markdown-it/index.d.ts ===
import MarkdownIt = require("./dist/index.cjs.js");

export = MarkdownIt;
=== END FILE ===
=== START FILE: ./node_modules/@types/geojson/index.d.ts ===
// Note: as of the RFC 7946 version of GeoJSON, Coordinate Reference Systems
// are no longer supported. (See https://tools.ietf.org/html/rfc7946#appendix-B)}

export as namespace GeoJSON;

/**
 * The valid values for the "type" property of GeoJSON geometry objects.
 * https://tools.ietf.org/html/rfc7946#section-1.4
 */
export type GeoJsonGeometryTypes = Geometry["type"];

/**
 * The value values for the "type" property of GeoJSON Objects.
 * https://tools.ietf.org/html/rfc7946#section-1.4
 */
export type GeoJsonTypes = GeoJSON["type"];

/**
 * Bounding box
 * https://tools.ietf.org/html/rfc7946#section-5
 */
export type BBox = [number, number, number, number] | [number, number, number, number, number, number];

/**
 * A Position is an array of coordinates.
 * https://tools.ietf.org/html/rfc7946#section-3.1.1
 * Array should contain between two and three elements.
 * The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values),
 * but the current specification only allows X, Y, and (optionally) Z to be defined.
 *
 * Note: the type will not be narrowed down to `[number, number] | [number, number, number]` due to
 * marginal benefits and the large impact of breaking change.
 *
 * See previous discussions on the type narrowing:
 * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/21590|Nov 2017}
 * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/67773|Dec 2023}
 * - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71441| Dec 2024}
 *
 * One can use a
 * {@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates|user-defined type guard that returns a type predicate}
 * to determine if a position is a 2D or 3D position.
 *
 * @example
 * import type { Position } from 'geojson';
 *
 * type StrictPosition = [x: number, y: number] | [x: number, y: number, z: number]
 *
 * function isStrictPosition(position: Position): position is StrictPosition {
 *   return position.length === 2 || position.length === 3
 * };
 *
 * let position: Position = [-116.91, 45.54];
 *
 * let x: number;
 * let y: number;
 * let z: number | undefined;
 *
 * if (isStrictPosition(position)) {
 *   // `tsc` would throw an error if we tried to destructure a fourth parameter
 * 	 [x, y, z] = position;
 * } else {
 * 	 throw new TypeError("Position is not a 2D or 3D point");
 * }
 */
export type Position = number[];

/**
 * The base GeoJSON object.
 * https://tools.ietf.org/html/rfc7946#section-3
 * The GeoJSON specification also allows foreign members
 * (https://tools.ietf.org/html/rfc7946#section-6.1)
 * Developers should use "&" type in TypeScript or extend the interface
 * to add these foreign members.
 */
export interface GeoJsonObject {
    // Don't include foreign members directly into this type def.
    // in order to preserve type safety.
    // [key: string]: any;
    /**
     * Specifies the type of GeoJSON object.
     */
    type: GeoJsonTypes;
    /**
     * Bounding box of the coordinate range of the object's Geometries, Features, or Feature Collections.
     * The value of the bbox member is an array of length 2*n where n is the number of dimensions
     * represented in the contained geometries, with all axes of the most southwesterly point
     * followed by all axes of the more northeasterly point.
     * The axes order of a bbox follows the axes order of geometries.
     * https://tools.ietf.org/html/rfc7946#section-5
     */
    bbox?: BBox | undefined;
}

/**
 * Union of GeoJSON objects.
 */
export type GeoJSON<G extends Geometry | null = Geometry, P = GeoJsonProperties> =
    | G
    | Feature<G, P>
    | FeatureCollection<G, P>;

/**
 * Geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3
 */
export type Geometry = Point | MultiPoint | LineString | MultiLineString | Polygon | MultiPolygon | GeometryCollection;
export type GeometryObject = Geometry;

/**
 * Point geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.2
 */
export interface Point extends GeoJsonObject {
    type: "Point";
    coordinates: Position;
}

/**
 * MultiPoint geometry object.
 *  https://tools.ietf.org/html/rfc7946#section-3.1.3
 */
export interface MultiPoint extends GeoJsonObject {
    type: "MultiPoint";
    coordinates: Position[];
}

/**
 * LineString geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.4
 */
export interface LineString extends GeoJsonObject {
    type: "LineString";
    coordinates: Position[];
}

/**
 * MultiLineString geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.5
 */
export interface MultiLineString extends GeoJsonObject {
    type: "MultiLineString";
    coordinates: Position[][];
}

/**
 * Polygon geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.6
 */
export interface Polygon extends GeoJsonObject {
    type: "Polygon";
    coordinates: Position[][];
}

/**
 * MultiPolygon geometry object.
 * https://tools.ietf.org/html/rfc7946#section-3.1.7
 */
export interface MultiPolygon extends GeoJsonObject {
    type: "MultiPolygon";
    coordinates: Position[][][];
}

/**
 * Geometry Collection
 * https://tools.ietf.org/html/rfc7946#section-3.1.8
 */
export interface GeometryCollection<G extends Geometry = Geometry> extends GeoJsonObject {
    type: "GeometryCollection";
    geometries: G[];
}

export type GeoJsonProperties = { [name: string]: any } | null;

/**
 * A feature object which contains a geometry and associated properties.
 * https://tools.ietf.org/html/rfc7946#section-3.2
 */
export interface Feature<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
    type: "Feature";
    /**
     * The feature's geometry
     */
    geometry: G;
    /**
     * A value that uniquely identifies this feature in a
     * https://tools.ietf.org/html/rfc7946#section-3.2.
     */
    id?: string | number | undefined;
    /**
     * Properties associated with this feature.
     */
    properties: P;
}

/**
 * A collection of feature objects.
 *  https://tools.ietf.org/html/rfc7946#section-3.3
 */
export interface FeatureCollection<G extends Geometry | null = Geometry, P = GeoJsonProperties> extends GeoJsonObject {
    type: "FeatureCollection";
    features: Array<Feature<G, P>>;
}
=== END FILE ===
=== START FILE: ./node_modules/@types/mdurl/index.d.ts ===
import mdurl = require("./build/index.cjs.js");

export = mdurl;
=== END FILE ===
=== START FILE: ./node_modules/@types/mdurl/build/index.cjs.d.ts ===
declare class Url {
    protocol: string;
    slashes: string;
    auth: string;
    port: string;
    hostname: string;
    hash: string;
    search: string;
    pathname: string;

    constructor();

    parse(url: string, slashesDenoteHost?: boolean): this;
    parseHost(host: string): void;
}

type Url_ = Url;

declare namespace mdurl {
    type Url = Url_;
}

declare const mdurl: {
    decode: {
        defaultChars: string;
        componentChars: string;
        /**
         * Decode percent-encoded string.
         */
        (str: string, exclude?: string): string;
    };

    encode: {
        defaultChars: string;
        componentChars: string;
        /**
         * Encode unsafe characters with percent-encoding, skipping already
         * encoded sequences.
         *
         * @param str string to encode
         * @param exclude list of characters to ignore (in addition to a-zA-Z0-9)
         * @param keepEscaped don't encode '%' in a correct escape sequence (default: true)
         */
        (str: string, exclude?: string, keepEscaped?: boolean): string;
    };

    format(url: Omit<mdurl.Url, "parse" | "parseHost">): string;

    parse(url: string | mdurl.Url, slashesDenoteHost?: boolean): mdurl.Url;
};

export = mdurl;
=== END FILE ===
=== START FILE: ./node_modules/@types/node/stream.d.ts ===
/**
 * A stream is an abstract interface for working with streaming data in Node.js.
 * The `node:stream` module provides an API for implementing the stream interface.
 *
 * There are many stream objects provided by Node.js. For instance, a [request to an HTTP server](https://nodejs.org/docs/latest-v22.x/api/http.html#class-httpincomingmessage)
 * and [`process.stdout`](https://nodejs.org/docs/latest-v22.x/api/process.html#processstdout) are both stream instances.
 *
 * Streams can be readable, writable, or both. All streams are instances of [`EventEmitter`](https://nodejs.org/docs/latest-v22.x/api/events.html#class-eventemitter).
 *
 * To access the `node:stream` module:
 *
 * ```js
 * import stream from 'node:stream';
 * ```
 *
 * The `node:stream` module is useful for creating new types of stream instances.
 * It is usually not necessary to use the `node:stream` module to consume streams.
 * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/stream.js)
 */
declare module "stream" {
    import { Abortable, EventEmitter } from "node:events";
    import { Blob as NodeBlob } from "node:buffer";
    import * as streamPromises from "node:stream/promises";
    import * as streamWeb from "node:stream/web";

    type ComposeFnParam = (source: any) => void;

    class Stream extends EventEmitter {
        pipe<T extends NodeJS.WritableStream>(
            destination: T,
            options?: {
                end?: boolean | undefined;
            },
        ): T;
        compose<T extends NodeJS.ReadableStream>(
            stream: T | ComposeFnParam | Iterable<T> | AsyncIterable<T>,
            options?: { signal: AbortSignal },
        ): T;
    }
    namespace Stream {
        export { Stream, streamPromises as promises };
    }
    namespace Stream {
        interface StreamOptions<T extends Stream> extends Abortable {
            emitClose?: boolean | undefined;
            highWaterMark?: number | undefined;
            objectMode?: boolean | undefined;
            construct?(this: T, callback: (error?: Error | null) => void): void;
            destroy?(this: T, error: Error | null, callback: (error?: Error | null) => void): void;
            autoDestroy?: boolean | undefined;
        }
        interface ReadableOptions<T extends Readable = Readable> extends StreamOptions<T> {
            encoding?: BufferEncoding | undefined;
            read?(this: T, size: number): void;
        }
        interface ArrayOptions {
            /**
             * The maximum concurrent invocations of `fn` to call on the stream at once.
             * @default 1
             */
            concurrency?: number;
            /** Allows destroying the stream if the signal is aborted. */
            signal?: AbortSignal;
        }
        /**
         * @since v0.9.4
         */
        class Readable extends Stream implements NodeJS.ReadableStream {
            /**
             * A utility method for creating Readable Streams out of iterators.
             * @since v12.3.0, v10.17.0
             * @param iterable Object implementing the `Symbol.asyncIterator` or `Symbol.iterator` iterable protocol. Emits an 'error' event if a null value is passed.
             * @param options Options provided to `new stream.Readable([options])`. By default, `Readable.from()` will set `options.objectMode` to `true`, unless this is explicitly opted out by setting `options.objectMode` to `false`.
             */
            static from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions): Readable;
            /**
             * A utility method for creating a `Readable` from a web `ReadableStream`.
             * @since v17.0.0
             * @experimental
             */
            static fromWeb(
                readableStream: streamWeb.ReadableStream,
                options?: Pick<ReadableOptions, "encoding" | "highWaterMark" | "objectMode" | "signal">,
            ): Readable;
            /**
             * A utility method for creating a web `ReadableStream` from a `Readable`.
             * @since v17.0.0
             * @experimental
             */
            static toWeb(
                streamReadable: Readable,
                options?: {
                    strategy?: streamWeb.QueuingStrategy | undefined;
                },
            ): streamWeb.ReadableStream;
            /**
             * Returns whether the stream has been read from or cancelled.
             * @since v16.8.0
             */
            static isDisturbed(stream: Readable | NodeJS.ReadableStream): boolean;
            /**
             * Returns whether the stream was destroyed or errored before emitting `'end'`.
             * @since v16.8.0
             * @experimental
             */
            readonly readableAborted: boolean;
            /**
             * Is `true` if it is safe to call {@link read}, which means
             * the stream has not been destroyed or emitted `'error'` or `'end'`.
             * @since v11.4.0
             */
            readable: boolean;
            /**
             * Returns whether `'data'` has been emitted.
             * @since v16.7.0, v14.18.0
             * @experimental
             */
            readonly readableDidRead: boolean;
            /**
             * Getter for the property `encoding` of a given `Readable` stream. The `encoding` property can be set using the {@link setEncoding} method.
             * @since v12.7.0
             */
            readonly readableEncoding: BufferEncoding | null;
            /**
             * Becomes `true` when [`'end'`](https://nodejs.org/docs/latest-v22.x/api/stream.html#event-end) event is emitted.
             * @since v12.9.0
             */
            readonly readableEnded: boolean;
            /**
             * This property reflects the current state of a `Readable` stream as described
             * in the [Three states](https://nodejs.org/docs/latest-v22.x/api/stream.html#three-states) section.
             * @since v9.4.0
             */
            readonly readableFlowing: boolean | null;
            /**
             * Returns the value of `highWaterMark` passed when creating this `Readable`.
             * @since v9.3.0
             */
            readonly readableHighWaterMark: number;
            /**
             * This property contains the number of bytes (or objects) in the queue
             * ready to be read. The value provides introspection data regarding
             * the status of the `highWaterMark`.
             * @since v9.4.0
             */
            readonly readableLength: number;
            /**
             * Getter for the property `objectMode` of a given `Readable` stream.
             * @since v12.3.0
             */
            readonly readableObjectMode: boolean;
            /**
             * Is `true` after `readable.destroy()` has been called.
             * @since v8.0.0
             */
            destroyed: boolean;
            /**
             * Is `true` after `'close'` has been emitted.
             * @since v18.0.0
             */
            readonly closed: boolean;
            /**
             * Returns error if the stream has been destroyed with an error.
             * @since v18.0.0
             */
            readonly errored: Error | null;
            constructor(opts?: ReadableOptions);
            _construct?(callback: (error?: Error | null) => void): void;
            _read(size: number): void;
            /**
             * The `readable.read()` method reads data out of the internal buffer and
             * returns it. If no data is available to be read, `null` is returned. By default,
             * the data is returned as a `Buffer` object unless an encoding has been
             * specified using the `readable.setEncoding()` method or the stream is operating
             * in object mode.
             *
             * The optional `size` argument specifies a specific number of bytes to read. If
             * `size` bytes are not available to be read, `null` will be returned _unless_ the
             * stream has ended, in which case all of the data remaining in the internal buffer
             * will be returned.
             *
             * If the `size` argument is not specified, all of the data contained in the
             * internal buffer will be returned.
             *
             * The `size` argument must be less than or equal to 1 GiB.
             *
             * The `readable.read()` method should only be called on `Readable` streams
             * operating in paused mode. In flowing mode, `readable.read()` is called
             * automatically until the internal buffer is fully drained.
             *
             * ```js
             * const readable = getReadableStreamSomehow();
             *
             * // 'readable' may be triggered multiple times as data is buffered in
             * readable.on('readable', () => {
             *   let chunk;
             *   console.log('Stream is readable (new data received in buffer)');
             *   // Use a loop to make sure we read all currently available data
             *   while (null !== (chunk = readable.read())) {
             *     console.log(`Read ${chunk.length} bytes of data...`);
             *   }
             * });
             *
             * // 'end' will be triggered once when there is no more data available
             * readable.on('end', () => {
             *   console.log('Reached end of stream.');
             * });
             * ```
             *
             * Each call to `readable.read()` returns a chunk of data, or `null`. The chunks
             * are not concatenated. A `while` loop is necessary to consume all data
             * currently in the buffer. When reading a large file `.read()` may return `null`,
             * having consumed all buffered content so far, but there is still more data to
             * come not yet buffered. In this case a new `'readable'` event will be emitted
             * when there is more data in the buffer. Finally the `'end'` event will be
             * emitted when there is no more data to come.
             *
             * Therefore to read a file's whole contents from a `readable`, it is necessary
             * to collect chunks across multiple `'readable'` events:
             *
             * ```js
             * const chunks = [];
             *
             * readable.on('readable', () => {
             *   let chunk;
             *   while (null !== (chunk = readable.read())) {
             *     chunks.push(chunk);
             *   }
             * });
             *
             * readable.on('end', () => {
             *   const content = chunks.join('');
             * });
             * ```
             *
             * A `Readable` stream in object mode will always return a single item from
             * a call to `readable.read(size)`, regardless of the value of the `size` argument.
             *
             * If the `readable.read()` method returns a chunk of data, a `'data'` event will
             * also be emitted.
             *
             * Calling {@link read} after the `'end'` event has
             * been emitted will return `null`. No runtime error will be raised.
             * @since v0.9.4
             * @param size Optional argument to specify how much data to read.
             */
            read(size?: number): any;
            /**
             * The `readable.setEncoding()` method sets the character encoding for
             * data read from the `Readable` stream.
             *
             * By default, no encoding is assigned and stream data will be returned as `Buffer` objects. Setting an encoding causes the stream data
             * to be returned as strings of the specified encoding rather than as `Buffer` objects. For instance, calling `readable.setEncoding('utf8')` will cause the
             * output data to be interpreted as UTF-8 data, and passed as strings. Calling `readable.setEncoding('hex')` will cause the data to be encoded in hexadecimal
             * string format.
             *
             * The `Readable` stream will properly handle multi-byte characters delivered
             * through the stream that would otherwise become improperly decoded if simply
             * pulled from the stream as `Buffer` objects.
             *
             * ```js
             * const readable = getReadableStreamSomehow();
             * readable.setEncoding('utf8');
             * readable.on('data', (chunk) => {
             *   assert.equal(typeof chunk, 'string');
             *   console.log('Got %d characters of string data:', chunk.length);
             * });
             * ```
             * @since v0.9.4
             * @param encoding The encoding to use.
             */
            setEncoding(encoding: BufferEncoding): this;
            /**
             * The `readable.pause()` method will cause a stream in flowing mode to stop
             * emitting `'data'` events, switching out of flowing mode. Any data that
             * becomes available will remain in the internal buffer.
             *
             * ```js
             * const readable = getReadableStreamSomehow();
             * readable.on('data', (chunk) => {
             *   console.log(`Received ${chunk.length} bytes of data.`);
             *   readable.pause();
             *   console.log('There will be no additional data for 1 second.');
             *   setTimeout(() => {
             *     console.log('Now data will start flowing again.');
             *     readable.resume();
             *   }, 1000);
             * });
             * ```
             *
             * The `readable.pause()` method has no effect if there is a `'readable'` event listener.
             * @since v0.9.4
             */
            pause(): this;
            /**
             * The `readable.resume()` method causes an explicitly paused `Readable` stream to
             * resume emitting `'data'` events, switching the stream into flowing mode.
             *
             * The `readable.resume()` method can be used to fully consume the data from a
             * stream without actually processing any of that data:
             *
             * ```js
             * getReadableStreamSomehow()
             *   .resume()
             *   .on('end', () => {
             *     console.log('Reached the end, but did not read anything.');
             *   });
             * ```
             *
             * The `readable.resume()` method has no effect if there is a `'readable'` event listener.
             * @since v0.9.4
             */
            resume(): this;
            /**
             * The `readable.isPaused()` method returns the current operating state of the `Readable`.
             * This is used primarily by the mechanism that underlies the `readable.pipe()` method.
             * In most typical cases, there will be no reason to use this method directly.
             *
             * ```js
             * const readable = new stream.Readable();
             *
             * readable.isPaused(); // === false
             * readable.pause();
             * readable.isPaused(); // === true
             * readable.resume();
             * readable.isPaused(); // === false
             * ```
             * @since v0.11.14
             */
            isPaused(): boolean;
            /**
             * The `readable.unpipe()` method detaches a `Writable` stream previously attached
             * using the {@link pipe} method.
             *
             * If the `destination` is not specified, then _all_ pipes are detached.
             *
             * If the `destination` is specified, but no pipe is set up for it, then
             * the method does nothing.
             *
             * ```js
             * import fs from 'node:fs';
             * const readable = getReadableStreamSomehow();
             * const writable = fs.createWriteStream('file.txt');
             * // All the data from readable goes into 'file.txt',
             * // but only for the first second.
             * readable.pipe(writable);
             * setTimeout(() => {
             *   console.log('Stop writing to file.txt.');
             *   readable.unpipe(writable);
             *   console.log('Manually close the file stream.');
             *   writable.end();
             * }, 1000);
             * ```
             * @since v0.9.4
             * @param destination Optional specific stream to unpipe
             */
            unpipe(destination?: NodeJS.WritableStream): this;
            /**
             * Passing `chunk` as `null` signals the end of the stream (EOF) and behaves the
             * same as `readable.push(null)`, after which no more data can be written. The EOF
             * signal is put at the end of the buffer and any buffered data will still be
             * flushed.
             *
             * The `readable.unshift()` method pushes a chunk of data back into the internal
             * buffer. This is useful in certain situations where a stream is being consumed by
             * code that needs to "un-consume" some amount of data that it has optimistically
             * pulled out of the source, so that the data can be passed on to some other party.
             *
             * The `stream.unshift(chunk)` method cannot be called after the `'end'` event
             * has been emitted or a runtime error will be thrown.
             *
             * Developers using `stream.unshift()` often should consider switching to
             * use of a `Transform` stream instead. See the `API for stream implementers` section for more information.
             *
             * ```js
             * // Pull off a header delimited by \n\n.
             * // Use unshift() if we get too much.
             * // Call the callback with (error, header, stream).
             * import { StringDecoder } from 'node:string_decoder';
             * function parseHeader(stream, callback) {
             *   stream.on('error', callback);
             *   stream.on('readable', onReadable);
             *   const decoder = new StringDecoder('utf8');
             *   let header = '';
             *   function onReadable() {
             *     let chunk;
             *     while (null !== (chunk = stream.read())) {
             *       const str = decoder.write(chunk);
             *       if (str.includes('\n\n')) {
             *         // Found the header boundary.
             *         const split = str.split(/\n\n/);
             *         header += split.shift();
             *         const remaining = split.join('\n\n');
             *         const buf = Buffer.from(remaining, 'utf8');
             *         stream.removeListener('error', callback);
             *         // Remove the 'readable' listener before unshifting.
             *         stream.removeListener('readable', onReadable);
             *         if (buf.length)
             *           stream.unshift(buf);
             *         // Now the body of the message can be read from the stream.
             *         callback(null, header, stream);
             *         return;
             *       }
             *       // Still reading the header.
             *       header += str;
             *     }
             *   }
             * }
             * ```
             *
             * Unlike {@link push}, `stream.unshift(chunk)` will not
             * end the reading process by resetting the internal reading state of the stream.
             * This can cause unexpected results if `readable.unshift()` is called during a
             * read (i.e. from within a {@link _read} implementation on a
             * custom stream). Following the call to `readable.unshift()` with an immediate {@link push} will reset the reading state appropriately,
             * however it is best to simply avoid calling `readable.unshift()` while in the
             * process of performing a read.
             * @since v0.9.11
             * @param chunk Chunk of data to unshift onto the read queue. For streams not operating in object mode, `chunk` must
             * be a {string}, {Buffer}, {TypedArray}, {DataView} or `null`. For object mode streams, `chunk` may be any JavaScript value.
             * @param encoding Encoding of string chunks. Must be a valid `Buffer` encoding, such as `'utf8'` or `'ascii'`.
             */
            unshift(chunk: any, encoding?: BufferEncoding): void;
            /**
             * Prior to Node.js 0.10, streams did not implement the entire `node:stream` module API as it is currently defined. (See `Compatibility` for more
             * information.)
             *
             * When using an older Node.js library that emits `'data'` events and has a {@link pause} method that is advisory only, the `readable.wrap()` method can be used to create a `Readable`
             * stream that uses
             * the old stream as its data source.
             *
             * It will rarely be necessary to use `readable.wrap()` but the method has been
             * provided as a convenience for interacting with older Node.js applications and
             * libraries.
             *
             * ```js
             * import { OldReader } from './old-api-module.js';
             * import { Readable } from 'node:stream';
             * const oreader = new OldReader();
             * const myReader = new Readable().wrap(oreader);
             *
             * myReader.on('readable', () => {
             *   myReader.read(); // etc.
             * });
             * ```
             * @since v0.9.4
             * @param stream An "old style" readable stream
             */
            wrap(stream: NodeJS.ReadableStream): this;
            push(chunk: any, encoding?: BufferEncoding): boolean;
            /**
             * The iterator created by this method gives users the option to cancel the destruction
             * of the stream if the `for await...of` loop is exited by `return`, `break`, or `throw`,
             * or if the iterator should destroy the stream if the stream emitted an error during iteration.
             * @since v16.3.0
             * @param options.destroyOnReturn When set to `false`, calling `return` on the async iterator,
             * or exiting a `for await...of` iteration using a `break`, `return`, or `throw` will not destroy the stream.
             * **Default: `true`**.
             */
            iterator(options?: { destroyOnReturn?: boolean }): NodeJS.AsyncIterator<any>;
            /**
             * This method allows mapping over the stream. The *fn* function will be called for every chunk in the stream.
             * If the *fn* function returns a promise - that promise will be `await`ed before being passed to the result stream.
             * @since v17.4.0, v16.14.0
             * @param fn a function to map over every chunk in the stream. Async or not.
             * @returns a stream mapped with the function *fn*.
             */
            map(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
            /**
             * This method allows filtering the stream. For each chunk in the stream the *fn* function will be called
             * and if it returns a truthy value, the chunk will be passed to the result stream.
             * If the *fn* function returns a promise - that promise will be `await`ed.
             * @since v17.4.0, v16.14.0
             * @param fn a function to filter chunks from the stream. Async or not.
             * @returns a stream filtered with the predicate *fn*.
             */
            filter(
                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
                options?: ArrayOptions,
            ): Readable;
            /**
             * This method allows iterating a stream. For each chunk in the stream the *fn* function will be called.
             * If the *fn* function returns a promise - that promise will be `await`ed.
             *
             * This method is different from `for await...of` loops in that it can optionally process chunks concurrently.
             * In addition, a `forEach` iteration can only be stopped by having passed a `signal` option
             * and aborting the related AbortController while `for await...of` can be stopped with `break` or `return`.
             * In either case the stream will be destroyed.
             *
             * This method is different from listening to the `'data'` event in that it uses the `readable` event
             * in the underlying machinary and can limit the number of concurrent *fn* calls.
             * @since v17.5.0
             * @param fn a function to call on each chunk of the stream. Async or not.
             * @returns a promise for when the stream has finished.
             */
            forEach(
                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => void | Promise<void>,
                options?: ArrayOptions,
            ): Promise<void>;
            /**
             * This method allows easily obtaining the contents of a stream.
             *
             * As this method reads the entire stream into memory, it negates the benefits of streams. It's intended
             * for interoperability and convenience, not as the primary way to consume streams.
             * @since v17.5.0
             * @returns a promise containing an array with the contents of the stream.
             */
            toArray(options?: Pick<ArrayOptions, "signal">): Promise<any[]>;
            /**
             * This method is similar to `Array.prototype.some` and calls *fn* on each chunk in the stream
             * until the awaited return value is `true` (or any truthy value). Once an *fn* call on a chunk
             * `await`ed return value is truthy, the stream is destroyed and the promise is fulfilled with `true`.
             * If none of the *fn* calls on the chunks return a truthy value, the promise is fulfilled with `false`.
             * @since v17.5.0
             * @param fn a function to call on each chunk of the stream. Async or not.
             * @returns a promise evaluating to `true` if *fn* returned a truthy value for at least one of the chunks.
             */
            some(
                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
                options?: ArrayOptions,
            ): Promise<boolean>;
            /**
             * This method is similar to `Array.prototype.find` and calls *fn* on each chunk in the stream
             * to find a chunk with a truthy value for *fn*. Once an *fn* call's awaited return value is truthy,
             * the stream is destroyed and the promise is fulfilled with value for which *fn* returned a truthy value.
             * If all of the *fn* calls on the chunks return a falsy value, the promise is fulfilled with `undefined`.
             * @since v17.5.0
             * @param fn a function to call on each chunk of the stream. Async or not.
             * @returns a promise evaluating to the first chunk for which *fn* evaluated with a truthy value,
             * or `undefined` if no element was found.
             */
            find<T>(
                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => data is T,
                options?: ArrayOptions,
            ): Promise<T | undefined>;
            find(
                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
                options?: ArrayOptions,
            ): Promise<any>;
            /**
             * This method is similar to `Array.prototype.every` and calls *fn* on each chunk in the stream
             * to check if all awaited return values are truthy value for *fn*. Once an *fn* call on a chunk
             * `await`ed return value is falsy, the stream is destroyed and the promise is fulfilled with `false`.
             * If all of the *fn* calls on the chunks return a truthy value, the promise is fulfilled with `true`.
             * @since v17.5.0
             * @param fn a function to call on each chunk of the stream. Async or not.
             * @returns a promise evaluating to `true` if *fn* returned a truthy value for every one of the chunks.
             */
            every(
                fn: (data: any, options?: Pick<ArrayOptions, "signal">) => boolean | Promise<boolean>,
                options?: ArrayOptions,
            ): Promise<boolean>;
            /**
             * This method returns a new stream by applying the given callback to each chunk of the stream
             * and then flattening the result.
             *
             * It is possible to return a stream or another iterable or async iterable from *fn* and the result streams
             * will be merged (flattened) into the returned stream.
             * @since v17.5.0
             * @param fn a function to map over every chunk in the stream. May be async. May be a stream or generator.
             * @returns a stream flat-mapped with the function *fn*.
             */
            flatMap(fn: (data: any, options?: Pick<ArrayOptions, "signal">) => any, options?: ArrayOptions): Readable;
            /**
             * This method returns a new stream with the first *limit* chunks dropped from the start.
             * @since v17.5.0
             * @param limit the number of chunks to drop from the readable.
             * @returns a stream with *limit* chunks dropped from the start.
             */
            drop(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
            /**
             * This method returns a new stream with the first *limit* chunks.
             * @since v17.5.0
             * @param limit the number of chunks to take from the readable.
             * @returns a stream with *limit* chunks taken.
             */
            take(limit: number, options?: Pick<ArrayOptions, "signal">): Readable;
            /**
             * This method returns a new stream with chunks of the underlying stream paired with a counter
             * in the form `[index, chunk]`. The first index value is `0` and it increases by 1 for each chunk produced.
             * @since v17.5.0
             * @returns a stream of indexed pairs.
             */
            asIndexedPairs(options?: Pick<ArrayOptions, "signal">): Readable;
            /**
             * This method calls *fn* on each chunk of the stream in order, passing it the result from the calculation
             * on the previous element. It returns a promise for the final value of the reduction.
             *
             * If no *initial* value is supplied the first chunk of the stream is used as the initial value.
             * If the stream is empty, the promise is rejected with a `TypeError` with the `ERR_INVALID_ARGS` code property.
             *
             * The reducer function iterates the stream element-by-element which means that there is no *concurrency* parameter
             * or parallelism. To perform a reduce concurrently, you can extract the async function to `readable.map` method.
             * @since v17.5.0
             * @param fn a reducer function to call over every chunk in the stream. Async or not.
             * @param initial the initial value to use in the reduction.
             * @returns a promise for the final value of the reduction.
             */
            reduce<T = any>(
                fn: (previous: any, data: any, options?: Pick<ArrayOptions, "signal">) => T,
                initial?: undefined,
                options?: Pick<ArrayOptions, "signal">,
            ): Promise<T>;
            reduce<T = any>(
                fn: (previous: T, data: any, options?: Pick<ArrayOptions, "signal">) => T,
                initial: T,
                options?: Pick<ArrayOptions, "signal">,
            ): Promise<T>;
            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
            /**
             * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'` event (unless `emitClose` is set to `false`). After this call, the readable
             * stream will release any internal resources and subsequent calls to `push()` will be ignored.
             *
             * Once `destroy()` has been called any further calls will be a no-op and no
             * further errors except from `_destroy()` may be emitted as `'error'`.
             *
             * Implementors should not override this method, but instead implement `readable._destroy()`.
             * @since v8.0.0
             * @param error Error which will be passed as payload in `'error'` event
             */
            destroy(error?: Error): this;
            /**
             * Event emitter
             * The defined events on documents including:
             * 1. close
             * 2. data
             * 3. end
             * 4. error
             * 5. pause
             * 6. readable
             * 7. resume
             */
            addListener(event: "close", listener: () => void): this;
            addListener(event: "data", listener: (chunk: any) => void): this;
            addListener(event: "end", listener: () => void): this;
            addListener(event: "error", listener: (err: Error) => void): this;
            addListener(event: "pause", listener: () => void): this;
            addListener(event: "readable", listener: () => void): this;
            addListener(event: "resume", listener: () => void): this;
            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
            emit(event: "close"): boolean;
            emit(event: "data", chunk: any): boolean;
            emit(event: "end"): boolean;
            emit(event: "error", err: Error): boolean;
            emit(event: "pause"): boolean;
            emit(event: "readable"): boolean;
            emit(event: "resume"): boolean;
            emit(event: string | symbol, ...args: any[]): boolean;
            on(event: "close", listener: () => void): this;
            on(event: "data", listener: (chunk: any) => void): this;
            on(event: "end", listener: () => void): this;
            on(event: "error", listener: (err: Error) => void): this;
            on(event: "pause", listener: () => void): this;
            on(event: "readable", listener: () => void): this;
            on(event: "resume", listener: () => void): this;
            on(event: string | symbol, listener: (...args: any[]) => void): this;
            once(event: "close", listener: () => void): this;
            once(event: "data", listener: (chunk: any) => void): this;
            once(event: "end", listener: () => void): this;
            once(event: "error", listener: (err: Error) => void): this;
            once(event: "pause", listener: () => void): this;
            once(event: "readable", listener: () => void): this;
            once(event: "resume", listener: () => void): this;
            once(event: string | symbol, listener: (...args: any[]) => void): this;
            prependListener(event: "close", listener: () => void): this;
            prependListener(event: "data", listener: (chunk: any) => void): this;
            prependListener(event: "end", listener: () => void): this;
            prependListener(event: "error", listener: (err: Error) => void): this;
            prependListener(event: "pause", listener: () => void): this;
            prependListener(event: "readable", listener: () => void): this;
            prependListener(event: "resume", listener: () => void): this;
            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
            prependOnceListener(event: "close", listener: () => void): this;
            prependOnceListener(event: "data", listener: (chunk: any) => void): this;
            prependOnceListener(event: "end", listener: () => void): this;
            prependOnceListener(event: "error", listener: (err: Error) => void): this;
            prependOnceListener(event: "pause", listener: () => void): this;
            prependOnceListener(event: "readable", listener: () => void): this;
            prependOnceListener(event: "resume", listener: () => void): this;
            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
            removeListener(event: "close", listener: () => void): this;
            removeListener(event: "data", listener: (chunk: any) => void): this;
            removeListener(event: "end", listener: () => void): this;
            removeListener(event: "error", listener: (err: Error) => void): this;
            removeListener(event: "pause", listener: () => void): this;
            removeListener(event: "readable", listener: () => void): this;
            removeListener(event: "resume", listener: () => void): this;
            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
            [Symbol.asyncIterator](): NodeJS.AsyncIterator<any>;
            /**
             * Calls `readable.destroy()` with an `AbortError` and returns a promise that fulfills when the stream is finished.
             * @since v20.4.0
             */
            [Symbol.asyncDispose](): Promise<void>;
        }
        interface WritableOptions<T extends Writable = Writable> extends StreamOptions<T> {
            decodeStrings?: boolean | undefined;
            defaultEncoding?: BufferEncoding | undefined;
            write?(
                this: T,
                chunk: any,
                encoding: BufferEncoding,
                callback: (error?: Error | null) => void,
            ): void;
            writev?(
                this: T,
                chunks: Array<{
                    chunk: any;
                    encoding: BufferEncoding;
                }>,
                callback: (error?: Error | null) => void,
            ): void;
            final?(this: T, callback: (error?: Error | null) => void): void;
        }
        /**
         * @since v0.9.4
         */
        class Writable extends Stream implements NodeJS.WritableStream {
            /**
             * A utility method for creating a `Writable` from a web `WritableStream`.
             * @since v17.0.0
             * @experimental
             */
            static fromWeb(
                writableStream: streamWeb.WritableStream,
                options?: Pick<WritableOptions, "decodeStrings" | "highWaterMark" | "objectMode" | "signal">,
            ): Writable;
            /**
             * A utility method for creating a web `WritableStream` from a `Writable`.
             * @since v17.0.0
             * @experimental
             */
            static toWeb(streamWritable: Writable): streamWeb.WritableStream;
            /**
             * Is `true` if it is safe to call `writable.write()`, which means
             * the stream has not been destroyed, errored, or ended.
             * @since v11.4.0
             */
            readonly writable: boolean;
            /**
             * Is `true` after `writable.end()` has been called. This property
             * does not indicate whether the data has been flushed, for this use `writable.writableFinished` instead.
             * @since v12.9.0
             */
            readonly writableEnded: boolean;
            /**
             * Is set to `true` immediately before the `'finish'` event is emitted.
             * @since v12.6.0
             */
            readonly writableFinished: boolean;
            /**
             * Return the value of `highWaterMark` passed when creating this `Writable`.
             * @since v9.3.0
             */
            readonly writableHighWaterMark: number;
            /**
             * This property contains the number of bytes (or objects) in the queue
             * ready to be written. The value provides introspection data regarding
             * the status of the `highWaterMark`.
             * @since v9.4.0
             */
            readonly writableLength: number;
            /**
             * Getter for the property `objectMode` of a given `Writable` stream.
             * @since v12.3.0
             */
            readonly writableObjectMode: boolean;
            /**
             * Number of times `writable.uncork()` needs to be
             * called in order to fully uncork the stream.
             * @since v13.2.0, v12.16.0
             */
            readonly writableCorked: number;
            /**
             * Is `true` after `writable.destroy()` has been called.
             * @since v8.0.0
             */
            destroyed: boolean;
            /**
             * Is `true` after `'close'` has been emitted.
             * @since v18.0.0
             */
            readonly closed: boolean;
            /**
             * Returns error if the stream has been destroyed with an error.
             * @since v18.0.0
             */
            readonly errored: Error | null;
            /**
             * Is `true` if the stream's buffer has been full and stream will emit `'drain'`.
             * @since v15.2.0, v14.17.0
             */
            readonly writableNeedDrain: boolean;
            constructor(opts?: WritableOptions);
            _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
            _writev?(
                chunks: Array<{
                    chunk: any;
                    encoding: BufferEncoding;
                }>,
                callback: (error?: Error | null) => void,
            ): void;
            _construct?(callback: (error?: Error | null) => void): void;
            _destroy(error: Error | null, callback: (error?: Error | null) => void): void;
            _final(callback: (error?: Error | null) => void): void;
            /**
             * The `writable.write()` method writes some data to the stream, and calls the
             * supplied `callback` once the data has been fully handled. If an error
             * occurs, the `callback` will be called with the error as its
             * first argument. The `callback` is called asynchronously and before `'error'` is
             * emitted.
             *
             * The return value is `true` if the internal buffer is less than the `highWaterMark` configured when the stream was created after admitting `chunk`.
             * If `false` is returned, further attempts to write data to the stream should
             * stop until the `'drain'` event is emitted.
             *
             * While a stream is not draining, calls to `write()` will buffer `chunk`, and
             * return false. Once all currently buffered chunks are drained (accepted for
             * delivery by the operating system), the `'drain'` event will be emitted.
             * Once `write()` returns false, do not write more chunks
             * until the `'drain'` event is emitted. While calling `write()` on a stream that
             * is not draining is allowed, Node.js will buffer all written chunks until
             * maximum memory usage occurs, at which point it will abort unconditionally.
             * Even before it aborts, high memory usage will cause poor garbage collector
             * performance and high RSS (which is not typically released back to the system,
             * even after the memory is no longer required). Since TCP sockets may never
             * drain if the remote peer does not read the data, writing a socket that is
             * not draining may lead to a remotely exploitable vulnerability.
             *
             * Writing data while the stream is not draining is particularly
             * problematic for a `Transform`, because the `Transform` streams are paused
             * by default until they are piped or a `'data'` or `'readable'` event handler
             * is added.
             *
             * If the data to be written can be generated or fetched on demand, it is
             * recommended to encapsulate the logic into a `Readable` and use {@link pipe}. However, if calling `write()` is preferred, it is
             * possible to respect backpressure and avoid memory issues using the `'drain'` event:
             *
             * ```js
             * function write(data, cb) {
             *   if (!stream.write(data)) {
             *     stream.once('drain', cb);
             *   } else {
             *     process.nextTick(cb);
             *   }
             * }
             *
             * // Wait for cb to be called before doing any other write.
             * write('hello', () => {
             *   console.log('Write completed, do more writes now.');
             * });
             * ```
             *
             * A `Writable` stream in object mode will always ignore the `encoding` argument.
             * @since v0.9.4
             * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
             * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
             * @param [encoding='utf8'] The encoding, if `chunk` is a string.
             * @param callback Callback for when this chunk of data is flushed.
             * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
             */
            write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
            write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
            /**
             * The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.
             * @since v0.11.15
             * @param encoding The new default encoding
             */
            setDefaultEncoding(encoding: BufferEncoding): this;
            /**
             * Calling the `writable.end()` method signals that no more data will be written
             * to the `Writable`. The optional `chunk` and `encoding` arguments allow one
             * final additional chunk of data to be written immediately before closing the
             * stream.
             *
             * Calling the {@link write} method after calling {@link end} will raise an error.
             *
             * ```js
             * // Write 'hello, ' and then end with 'world!'.
             * import fs from 'node:fs';
             * const file = fs.createWriteStream('example.txt');
             * file.write('hello, ');
             * file.end('world!');
             * // Writing more now is not allowed!
             * ```
             * @since v0.9.4
             * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
             * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
             * @param encoding The encoding if `chunk` is a string
             * @param callback Callback for when the stream is finished.
             */
            end(cb?: () => void): this;
            end(chunk: any, cb?: () => void): this;
            end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
            /**
             * The `writable.cork()` method forces all written data to be buffered in memory.
             * The buffered data will be flushed when either the {@link uncork} or {@link end} methods are called.
             *
             * The primary intent of `writable.cork()` is to accommodate a situation in which
             * several small chunks are written to the stream in rapid succession. Instead of
             * immediately forwarding them to the underlying destination, `writable.cork()` buffers all the chunks until `writable.uncork()` is called, which will pass them
             * all to `writable._writev()`, if present. This prevents a head-of-line blocking
             * situation where data is being buffered while waiting for the first small chunk
             * to be processed. However, use of `writable.cork()` without implementing `writable._writev()` may have an adverse effect on throughput.
             *
             * See also: `writable.uncork()`, `writable._writev()`.
             * @since v0.11.2
             */
            cork(): void;
            /**
             * The `writable.uncork()` method flushes all data buffered since {@link cork} was called.
             *
             * When using `writable.cork()` and `writable.uncork()` to manage the buffering
             * of writes to a stream, defer calls to `writable.uncork()` using `process.nextTick()`. Doing so allows batching of all `writable.write()` calls that occur within a given Node.js event
             * loop phase.
             *
             * ```js
             * stream.cork();
             * stream.write('some ');
             * stream.write('data ');
             * process.nextTick(() => stream.uncork());
             * ```
             *
             * If the `writable.cork()` method is called multiple times on a stream, the
             * same number of calls to `writable.uncork()` must be called to flush the buffered
             * data.
             *
             * ```js
             * stream.cork();
             * stream.write('some ');
             * stream.cork();
             * stream.write('data ');
             * process.nextTick(() => {
             *   stream.uncork();
             *   // The data will not be flushed until uncork() is called a second time.
             *   stream.uncork();
             * });
             * ```
             *
             * See also: `writable.cork()`.
             * @since v0.11.2
             */
            uncork(): void;
            /**
             * Destroy the stream. Optionally emit an `'error'` event, and emit a `'close'` event (unless `emitClose` is set to `false`). After this call, the writable
             * stream has ended and subsequent calls to `write()` or `end()` will result in
             * an `ERR_STREAM_DESTROYED` error.
             * This is a destructive and immediate way to destroy a stream. Previous calls to `write()` may not have drained, and may trigger an `ERR_STREAM_DESTROYED` error.
             * Use `end()` instead of destroy if data should flush before close, or wait for
             * the `'drain'` event before destroying the stream.
             *
             * Once `destroy()` has been called any further calls will be a no-op and no
             * further errors except from `_destroy()` may be emitted as `'error'`.
             *
             * Implementors should not override this method,
             * but instead implement `writable._destroy()`.
             * @since v8.0.0
             * @param error Optional, an error to emit with `'error'` event.
             */
            destroy(error?: Error): this;
            /**
             * Event emitter
             * The defined events on documents including:
             * 1. close
             * 2. drain
             * 3. error
             * 4. finish
             * 5. pipe
             * 6. unpipe
             */
            addListener(event: "close", listener: () => void): this;
            addListener(event: "drain", listener: () => void): this;
            addListener(event: "error", listener: (err: Error) => void): this;
            addListener(event: "finish", listener: () => void): this;
            addListener(event: "pipe", listener: (src: Readable) => void): this;
            addListener(event: "unpipe", listener: (src: Readable) => void): this;
            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
            emit(event: "close"): boolean;
            emit(event: "drain"): boolean;
            emit(event: "error", err: Error): boolean;
            emit(event: "finish"): boolean;
            emit(event: "pipe", src: Readable): boolean;
            emit(event: "unpipe", src: Readable): boolean;
            emit(event: string | symbol, ...args: any[]): boolean;
            on(event: "close", listener: () => void): this;
            on(event: "drain", listener: () => void): this;
            on(event: "error", listener: (err: Error) => void): this;
            on(event: "finish", listener: () => void): this;
            on(event: "pipe", listener: (src: Readable) => void): this;
            on(event: "unpipe", listener: (src: Readable) => void): this;
            on(event: string | symbol, listener: (...args: any[]) => void): this;
            once(event: "close", listener: () => void): this;
            once(event: "drain", listener: () => void): this;
            once(event: "error", listener: (err: Error) => void): this;
            once(event: "finish", listener: () => void): this;
            once(event: "pipe", listener: (src: Readable) => void): this;
            once(event: "unpipe", listener: (src: Readable) => void): this;
            once(event: string | symbol, listener: (...args: any[]) => void): this;
            prependListener(event: "close", listener: () => void): this;
            prependListener(event: "drain", listener: () => void): this;
            prependListener(event: "error", listener: (err: Error) => void): this;
            prependListener(event: "finish", listener: () => void): this;
            prependListener(event: "pipe", listener: (src: Readable) => void): this;
            prependListener(event: "unpipe", listener: (src: Readable) => void): this;
            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
            prependOnceListener(event: "close", listener: () => void): this;
            prependOnceListener(event: "drain", listener: () => void): this;
            prependOnceListener(event: "error", listener: (err: Error) => void): this;
            prependOnceListener(event: "finish", listener: () => void): this;
            prependOnceListener(event: "pipe", listener: (src: Readable) => void): this;
            prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this;
            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
            removeListener(event: "close", listener: () => void): this;
            removeListener(event: "drain", listener: () => void): this;
            removeListener(event: "error", listener: (err: Error) => void): this;
            removeListener(event: "finish", listener: () => void): this;
            removeListener(event: "pipe", listener: (src: Readable) => void): this;
            removeListener(event: "unpipe", listener: (src: Readable) => void): this;
            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
        }
        interface DuplexOptions<T extends Duplex = Duplex> extends ReadableOptions<T>, WritableOptions<T> {
            allowHalfOpen?: boolean | undefined;
            readableObjectMode?: boolean | undefined;
            writableObjectMode?: boolean | undefined;
            readableHighWaterMark?: number | undefined;
            writableHighWaterMark?: number | undefined;
            writableCorked?: number | undefined;
        }
        /**
         * Duplex streams are streams that implement both the `Readable` and `Writable` interfaces.
         *
         * Examples of `Duplex` streams include:
         *
         * * `TCP sockets`
         * * `zlib streams`
         * * `crypto streams`
         * @since v0.9.4
         */
        class Duplex extends Stream implements NodeJS.ReadWriteStream {
            /**
             * If `false` then the stream will automatically end the writable side when the
             * readable side ends. Set initially by the `allowHalfOpen` constructor option,
             * which defaults to `true`.
             *
             * This can be changed manually to change the half-open behavior of an existing
             * `Duplex` stream instance, but must be changed before the `'end'` event is emitted.
             * @since v0.9.4
             */
            allowHalfOpen: boolean;
            constructor(opts?: DuplexOptions);
            /**
             * A utility method for creating duplex streams.
             *
             * - `Stream` converts writable stream into writable `Duplex` and readable stream
             *   to `Duplex`.
             * - `Blob` converts into readable `Duplex`.
             * - `string` converts into readable `Duplex`.
             * - `ArrayBuffer` converts into readable `Duplex`.
             * - `AsyncIterable` converts into a readable `Duplex`. Cannot yield `null`.
             * - `AsyncGeneratorFunction` converts into a readable/writable transform
             *   `Duplex`. Must take a source `AsyncIterable` as first parameter. Cannot yield
             *   `null`.
             * - `AsyncFunction` converts into a writable `Duplex`. Must return
             *   either `null` or `undefined`
             * - `Object ({ writable, readable })` converts `readable` and
             *   `writable` into `Stream` and then combines them into `Duplex` where the
             *   `Duplex` will write to the `writable` and read from the `readable`.
             * - `Promise` converts into readable `Duplex`. Value `null` is ignored.
             *
             * @since v16.8.0
             */
            static from(
                src:
                    | Stream
                    | NodeBlob
                    | ArrayBuffer
                    | string
                    | Iterable<any>
                    | AsyncIterable<any>
                    | AsyncGeneratorFunction
                    | Promise<any>
                    | Object,
            ): Duplex;
            /**
             * A utility method for creating a web `ReadableStream` and `WritableStream` from a `Duplex`.
             * @since v17.0.0
             * @experimental
             */
            static toWeb(streamDuplex: Duplex): {
                readable: streamWeb.ReadableStream;
                writable: streamWeb.WritableStream;
            };
            /**
             * A utility method for creating a `Duplex` from a web `ReadableStream` and `WritableStream`.
             * @since v17.0.0
             * @experimental
             */
            static fromWeb(
                duplexStream: {
                    readable: streamWeb.ReadableStream;
                    writable: streamWeb.WritableStream;
                },
                options?: Pick<
                    DuplexOptions,
                    "allowHalfOpen" | "decodeStrings" | "encoding" | "highWaterMark" | "objectMode" | "signal"
                >,
            ): Duplex;
            /**
             * Event emitter
             * The defined events on documents including:
             * 1.  close
             * 2.  data
             * 3.  drain
             * 4.  end
             * 5.  error
             * 6.  finish
             * 7.  pause
             * 8.  pipe
             * 9.  readable
             * 10. resume
             * 11. unpipe
             */
            addListener(event: "close", listener: () => void): this;
            addListener(event: "data", listener: (chunk: any) => void): this;
            addListener(event: "drain", listener: () => void): this;
            addListener(event: "end", listener: () => void): this;
            addListener(event: "error", listener: (err: Error) => void): this;
            addListener(event: "finish", listener: () => void): this;
            addListener(event: "pause", listener: () => void): this;
            addListener(event: "pipe", listener: (src: Readable) => void): this;
            addListener(event: "readable", listener: () => void): this;
            addListener(event: "resume", listener: () => void): this;
            addListener(event: "unpipe", listener: (src: Readable) => void): this;
            addListener(event: string | symbol, listener: (...args: any[]) => void): this;
            emit(event: "close"): boolean;
            emit(event: "data", chunk: any): boolean;
            emit(event: "drain"): boolean;
            emit(event: "end"): boolean;
            emit(event: "error", err: Error): boolean;
            emit(event: "finish"): boolean;
            emit(event: "pause"): boolean;
            emit(event: "pipe", src: Readable): boolean;
            emit(event: "readable"): boolean;
            emit(event: "resume"): boolean;
            emit(event: "unpipe", src: Readable): boolean;
            emit(event: string | symbol, ...args: any[]): boolean;
            on(event: "close", listener: () => void): this;
            on(event: "data", listener: (chunk: any) => void): this;
            on(event: "drain", listener: () => void): this;
            on(event: "end", listener: () => void): this;
            on(event: "error", listener: (err: Error) => void): this;
            on(event: "finish", listener: () => void): this;
            on(event: "pause", listener: () => void): this;
            on(event: "pipe", listener: (src: Readable) => void): this;
            on(event: "readable", listener: () => void): this;
            on(event: "resume", listener: () => void): this;
            on(event: "unpipe", listener: (src: Readable) => void): this;
            on(event: string | symbol, listener: (...args: any[]) => void): this;
            once(event: "close", listener: () => void): this;
            once(event: "data", listener: (chunk: any) => void): this;
            once(event: "drain", listener: () => void): this;
            once(event: "end", listener: () => void): this;
            once(event: "error", listener: (err: Error) => void): this;
            once(event: "finish", listener: () => void): this;
            once(event: "pause", listener: () => void): this;
            once(event: "pipe", listener: (src: Readable) => void): this;
            once(event: "readable", listener: () => void): this;
            once(event: "resume", listener: () => void): this;
            once(event: "unpipe", listener: (src: Readable) => void): this;
            once(event: string | symbol, listener: (...args: any[]) => void): this;
            prependListener(event: "close", listener: () => void): this;
            prependListener(event: "data", listener: (chunk: any) => void): this;
            prependListener(event: "drain", listener: () => void): this;
            prependListener(event: "end", listener: () => void): this;
            prependListener(event: "error", listener: (err: Error) => void): this;
            prependListener(event: "finish", listener: () => void): this;
            prependListener(event: "pause", listener: () => void): this;
            prependListener(event: "pipe", listener: (src: Readable) => void): this;
            prependListener(event: "readable", listener: () => void): this;
            prependListener(event: "resume", listener: () => void): this;
            prependListener(event: "unpipe", listener: (src: Readable) => void): this;
            prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
            prependOnceListener(event: "close", listener: () => void): this;
            prependOnceListener(event: "data", listener: (chunk: any) => void): this;
            prependOnceListener(event: "drain", listener: () => void): this;
            prependOnceListener(event: "end", listener: () => void): this;
            prependOnceListener(event: "error", listener: (err: Error) => void): this;
            prependOnceListener(event: "finish", listener: () => void): this;
            prependOnceListener(event: "pause", listener: () => void): this;
            prependOnceListener(event: "pipe", listener: (src: Readable) => void): this;
            prependOnceListener(event: "readable", listener: () => void): this;
            prependOnceListener(event: "resume", listener: () => void): this;
            prependOnceListener(event: "unpipe", listener: (src: Readable) => void): this;
            prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
            removeListener(event: "close", listener: () => void): this;
            removeListener(event: "data", listener: (chunk: any) => void): this;
            removeListener(event: "drain", listener: () => void): this;
            removeListener(event: "end", listener: () => void): this;
            removeListener(event: "error", listener: (err: Error) => void): this;
            removeListener(event: "finish", listener: () => void): this;
            removeListener(event: "pause", listener: () => void): this;
            removeListener(event: "pipe", listener: (src: Readable) => void): this;
            removeListener(event: "readable", listener: () => void): this;
            removeListener(event: "resume", listener: () => void): this;
            removeListener(event: "unpipe", listener: (src: Readable) => void): this;
            removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
        }
        interface Duplex extends Readable, Writable {}
        /**
         * The utility function `duplexPair` returns an Array with two items,
         * each being a `Duplex` stream connected to the other side:
         *
         * ```js
         * const [ sideA, sideB ] = duplexPair();
         * ```
         *
         * Whatever is written to one stream is made readable on the other. It provides
         * behavior analogous to a network connection, where the data written by the client
         * becomes readable by the server, and vice-versa.
         *
         * The Duplex streams are symmetrical; one or the other may be used without any
         * difference in behavior.
         * @param options A value to pass to both {@link Duplex} constructors,
         * to set options such as buffering.
         * @since v22.6.0
         */
        function duplexPair(options?: DuplexOptions): [Duplex, Duplex];
        type TransformCallback = (error?: Error | null, data?: any) => void;
        interface TransformOptions<T extends Transform = Transform> extends DuplexOptions<T> {
            transform?(this: T, chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
            flush?(this: T, callback: TransformCallback): void;
        }
        /**
         * Transform streams are `Duplex` streams where the output is in some way
         * related to the input. Like all `Duplex` streams, `Transform` streams
         * implement both the `Readable` and `Writable` interfaces.
         *
         * Examples of `Transform` streams include:
         *
         * * `zlib streams`
         * * `crypto streams`
         * @since v0.9.4
         */
        class Transform extends Duplex {
            constructor(opts?: TransformOptions);
            _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback): void;
            _flush(callback: TransformCallback): void;
        }
        /**
         * The `stream.PassThrough` class is a trivial implementation of a `Transform` stream that simply passes the input bytes across to the output. Its purpose is
         * primarily for examples and testing, but there are some use cases where `stream.PassThrough` is useful as a building block for novel sorts of streams.
         */
        class PassThrough extends Transform {}
        /**
         * A stream to attach a signal to.
         *
         * Attaches an AbortSignal to a readable or writeable stream. This lets code
         * control stream destruction using an `AbortController`.
         *
         * Calling `abort` on the `AbortController` corresponding to the passed `AbortSignal` will behave the same way as calling `.destroy(new AbortError())` on the
         * stream, and `controller.error(new AbortError())` for webstreams.
         *
         * ```js
         * import fs from 'node:fs';
         *
         * const controller = new AbortController();
         * const read = addAbortSignal(
         *   controller.signal,
         *   fs.createReadStream(('object.json')),
         * );
         * // Later, abort the operation closing the stream
         * controller.abort();
         * ```
         *
         * Or using an `AbortSignal` with a readable stream as an async iterable:
         *
         * ```js
         * const controller = new AbortController();
         * setTimeout(() => controller.abort(), 10_000); // set a timeout
         * const stream = addAbortSignal(
         *   controller.signal,
         *   fs.createReadStream(('object.json')),
         * );
         * (async () => {
         *   try {
         *     for await (const chunk of stream) {
         *       await process(chunk);
         *     }
         *   } catch (e) {
         *     if (e.name === 'AbortError') {
         *       // The operation was cancelled
         *     } else {
         *       throw e;
         *     }
         *   }
         * })();
         * ```
         *
         * Or using an `AbortSignal` with a ReadableStream:
         *
         * ```js
         * const controller = new AbortController();
         * const rs = new ReadableStream({
         *   start(controller) {
         *     controller.enqueue('hello');
         *     controller.enqueue('world');
         *     controller.close();
         *   },
         * });
         *
         * addAbortSignal(controller.signal, rs);
         *
         * finished(rs, (err) => {
         *   if (err) {
         *     if (err.name === 'AbortError') {
         *       // The operation was cancelled
         *     }
         *   }
         * });
         *
         * const reader = rs.getReader();
         *
         * reader.read().then(({ value, done }) => {
         *   console.log(value); // hello
         *   console.log(done); // false
         *   controller.abort();
         * });
         * ```
         * @since v15.4.0
         * @param signal A signal representing possible cancellation
         * @param stream A stream to attach a signal to.
         */
        function addAbortSignal<T extends Stream>(signal: AbortSignal, stream: T): T;
        /**
         * Returns the default highWaterMark used by streams.
         * Defaults to `65536` (64 KiB), or `16` for `objectMode`.
         * @since v19.9.0
         */
        function getDefaultHighWaterMark(objectMode: boolean): number;
        /**
         * Sets the default highWaterMark used by streams.
         * @since v19.9.0
         * @param value highWaterMark value
         */
        function setDefaultHighWaterMark(objectMode: boolean, value: number): void;
        interface FinishedOptions extends Abortable {
            error?: boolean | undefined;
            readable?: boolean | undefined;
            writable?: boolean | undefined;
        }
        /**
         * A readable and/or writable stream/webstream.
         *
         * A function to get notified when a stream is no longer readable, writable
         * or has experienced an error or a premature close event.
         *
         * ```js
         * import { finished } from 'node:stream';
         * import fs from 'node:fs';
         *
         * const rs = fs.createReadStream('archive.tar');
         *
         * finished(rs, (err) => {
         *   if (err) {
         *     console.error('Stream failed.', err);
         *   } else {
         *     console.log('Stream is done reading.');
         *   }
         * });
         *
         * rs.resume(); // Drain the stream.
         * ```
         *
         * Especially useful in error handling scenarios where a stream is destroyed
         * prematurely (like an aborted HTTP request), and will not emit `'end'` or `'finish'`.
         *
         * The `finished` API provides [`promise version`](https://nodejs.org/docs/latest-v22.x/api/stream.html#streamfinishedstream-options).
         *
         * `stream.finished()` leaves dangling event listeners (in particular `'error'`, `'end'`, `'finish'` and `'close'`) after `callback` has been
         * invoked. The reason for this is so that unexpected `'error'` events (due to
         * incorrect stream implementations) do not cause unexpected crashes.
         * If this is unwanted behavior then the returned cleanup function needs to be
         * invoked in the callback:
         *
         * ```js
         * const cleanup = finished(rs, (err) => {
         *   cleanup();
         *   // ...
         * });
         * ```
         * @since v10.0.0
         * @param stream A readable and/or writable stream.
         * @param callback A callback function that takes an optional error argument.
         * @returns A cleanup function which removes all registered listeners.
         */
        function finished(
            stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
            options: FinishedOptions,
            callback: (err?: NodeJS.ErrnoException | null) => void,
        ): () => void;
        function finished(
            stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
            callback: (err?: NodeJS.ErrnoException | null) => void,
        ): () => void;
        namespace finished {
            function __promisify__(
                stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
                options?: FinishedOptions,
            ): Promise<void>;
        }
        type PipelineSourceFunction<T> = () => Iterable<T> | AsyncIterable<T>;
        type PipelineSource<T> = Iterable<T> | AsyncIterable<T> | NodeJS.ReadableStream | PipelineSourceFunction<T>;
        type PipelineTransform<S extends PipelineTransformSource<any>, U> =
            | NodeJS.ReadWriteStream
            | ((
                source: S extends (...args: any[]) => Iterable<infer ST> | AsyncIterable<infer ST> ? AsyncIterable<ST>
                    : S,
            ) => AsyncIterable<U>);
        type PipelineTransformSource<T> = PipelineSource<T> | PipelineTransform<any, T>;
        type PipelineDestinationIterableFunction<T> = (source: AsyncIterable<T>) => AsyncIterable<any>;
        type PipelineDestinationPromiseFunction<T, P> = (source: AsyncIterable<T>) => Promise<P>;
        type PipelineDestination<S extends PipelineTransformSource<any>, P> = S extends
            PipelineTransformSource<infer ST> ?
                | NodeJS.WritableStream
                | PipelineDestinationIterableFunction<ST>
                | PipelineDestinationPromiseFunction<ST, P>
            : never;
        type PipelineCallback<S extends PipelineDestination<any, any>> = S extends
            PipelineDestinationPromiseFunction<any, infer P> ? (err: NodeJS.ErrnoException | null, value: P) => void
            : (err: NodeJS.ErrnoException | null) => void;
        type PipelinePromise<S extends PipelineDestination<any, any>> = S extends
            PipelineDestinationPromiseFunction<any, infer P> ? Promise<P> : Promise<void>;
        interface PipelineOptions {
            signal?: AbortSignal | undefined;
            end?: boolean | undefined;
        }
        /**
         * A module method to pipe between streams and generators forwarding errors and
         * properly cleaning up and provide a callback when the pipeline is complete.
         *
         * ```js
         * import { pipeline } from 'node:stream';
         * import fs from 'node:fs';
         * import zlib from 'node:zlib';
         *
         * // Use the pipeline API to easily pipe a series of streams
         * // together and get notified when the pipeline is fully done.
         *
         * // A pipeline to gzip a potentially huge tar file efficiently:
         *
         * pipeline(
         *   fs.createReadStream('archive.tar'),
         *   zlib.createGzip(),
         *   fs.createWriteStream('archive.tar.gz'),
         *   (err) => {
         *     if (err) {
         *       console.error('Pipeline failed.', err);
         *     } else {
         *       console.log('Pipeline succeeded.');
         *     }
         *   },
         * );
         * ```
         *
         * The `pipeline` API provides a [`promise version`](https://nodejs.org/docs/latest-v22.x/api/stream.html#streampipelinesource-transforms-destination-options).
         *
         * `stream.pipeline()` will call `stream.destroy(err)` on all streams except:
         *
         * * `Readable` streams which have emitted `'end'` or `'close'`.
         * * `Writable` streams which have emitted `'finish'` or `'close'`.
         *
         * `stream.pipeline()` leaves dangling event listeners on the streams
         * after the `callback` has been invoked. In the case of reuse of streams after
         * failure, this can cause event listener leaks and swallowed errors. If the last
         * stream is readable, dangling event listeners will be removed so that the last
         * stream can be consumed later.
         *
         * `stream.pipeline()` closes all the streams when an error is raised.
         * The `IncomingRequest` usage with `pipeline` could lead to an unexpected behavior
         * once it would destroy the socket without sending the expected response.
         * See the example below:
         *
         * ```js
         * import fs from 'node:fs';
         * import http from 'node:http';
         * import { pipeline } from 'node:stream';
         *
         * const server = http.createServer((req, res) => {
         *   const fileStream = fs.createReadStream('./fileNotExist.txt');
         *   pipeline(fileStream, res, (err) => {
         *     if (err) {
         *       console.log(err); // No such file
         *       // this message can't be sent once `pipeline` already destroyed the socket
         *       return res.end('error!!!');
         *     }
         *   });
         * });
         * ```
         * @since v10.0.0
         * @param callback Called when the pipeline is fully done.
         */
        function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
            source: A,
            destination: B,
            callback: PipelineCallback<B>,
        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
        function pipeline<
            A extends PipelineSource<any>,
            T1 extends PipelineTransform<A, any>,
            B extends PipelineDestination<T1, any>,
        >(
            source: A,
            transform1: T1,
            destination: B,
            callback: PipelineCallback<B>,
        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
        function pipeline<
            A extends PipelineSource<any>,
            T1 extends PipelineTransform<A, any>,
            T2 extends PipelineTransform<T1, any>,
            B extends PipelineDestination<T2, any>,
        >(
            source: A,
            transform1: T1,
            transform2: T2,
            destination: B,
            callback: PipelineCallback<B>,
        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
        function pipeline<
            A extends PipelineSource<any>,
            T1 extends PipelineTransform<A, any>,
            T2 extends PipelineTransform<T1, any>,
            T3 extends PipelineTransform<T2, any>,
            B extends PipelineDestination<T3, any>,
        >(
            source: A,
            transform1: T1,
            transform2: T2,
            transform3: T3,
            destination: B,
            callback: PipelineCallback<B>,
        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
        function pipeline<
            A extends PipelineSource<any>,
            T1 extends PipelineTransform<A, any>,
            T2 extends PipelineTransform<T1, any>,
            T3 extends PipelineTransform<T2, any>,
            T4 extends PipelineTransform<T3, any>,
            B extends PipelineDestination<T4, any>,
        >(
            source: A,
            transform1: T1,
            transform2: T2,
            transform3: T3,
            transform4: T4,
            destination: B,
            callback: PipelineCallback<B>,
        ): B extends NodeJS.WritableStream ? B : NodeJS.WritableStream;
        function pipeline(
            streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
            callback: (err: NodeJS.ErrnoException | null) => void,
        ): NodeJS.WritableStream;
        function pipeline(
            stream1: NodeJS.ReadableStream,
            stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
            ...streams: Array<
                NodeJS.ReadWriteStream | NodeJS.WritableStream | ((err: NodeJS.ErrnoException | null) => void)
            >
        ): NodeJS.WritableStream;
        namespace pipeline {
            function __promisify__<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
                source: A,
                destination: B,
                options?: PipelineOptions,
            ): PipelinePromise<B>;
            function __promisify__<
                A extends PipelineSource<any>,
                T1 extends PipelineTransform<A, any>,
                B extends PipelineDestination<T1, any>,
            >(
                source: A,
                transform1: T1,
                destination: B,
                options?: PipelineOptions,
            ): PipelinePromise<B>;
            function __promisify__<
                A extends PipelineSource<any>,
                T1 extends PipelineTransform<A, any>,
                T2 extends PipelineTransform<T1, any>,
                B extends PipelineDestination<T2, any>,
            >(
                source: A,
                transform1: T1,
                transform2: T2,
                destination: B,
                options?: PipelineOptions,
            ): PipelinePromise<B>;
            function __promisify__<
                A extends PipelineSource<any>,
                T1 extends PipelineTransform<A, any>,
                T2 extends PipelineTransform<T1, any>,
                T3 extends PipelineTransform<T2, any>,
                B extends PipelineDestination<T3, any>,
            >(
                source: A,
                transform1: T1,
                transform2: T2,
                transform3: T3,
                destination: B,
                options?: PipelineOptions,
            ): PipelinePromise<B>;
            function __promisify__<
                A extends PipelineSource<any>,
                T1 extends PipelineTransform<A, any>,
                T2 extends PipelineTransform<T1, any>,
                T3 extends PipelineTransform<T2, any>,
                T4 extends PipelineTransform<T3, any>,
                B extends PipelineDestination<T4, any>,
            >(
                source: A,
                transform1: T1,
                transform2: T2,
                transform3: T3,
                transform4: T4,
                destination: B,
                options?: PipelineOptions,
            ): PipelinePromise<B>;
            function __promisify__(
                streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
                options?: PipelineOptions,
            ): Promise<void>;
            function __promisify__(
                stream1: NodeJS.ReadableStream,
                stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
                ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
            ): Promise<void>;
        }
        interface Pipe {
            close(): void;
            hasRef(): boolean;
            ref(): void;
            unref(): void;
        }
        /**
         * Returns whether the stream has encountered an error.
         * @since v17.3.0, v16.14.0
         * @experimental
         */
        function isErrored(stream: Readable | Writable | NodeJS.ReadableStream | NodeJS.WritableStream): boolean;
        /**
         * Returns whether the stream is readable.
         * @since v17.4.0, v16.14.0
         * @experimental
         */
        function isReadable(stream: Readable | NodeJS.ReadableStream): boolean;
    }
    export = Stream;
}
declare module "node:stream" {
    import stream = require("stream");
    export = stream;
}
=== END FILE ===
=== START FILE: ./node_modules/@types/node/tty.d.ts ===
/**
 * The `node:tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes. In most cases, it will not be necessary or possible to use this module
 * directly. However, it can be accessed using:
 *
 * ```js
 * import tty from 'node:tty';
 * ```
 *
 * When Node.js detects that it is being run with a text terminal ("TTY")
 * attached, `process.stdin` will, by default, be initialized as an instance of `tty.ReadStream` and both `process.stdout` and `process.stderr` will, by
 * default, be instances of `tty.WriteStream`. The preferred method of determining
 * whether Node.js is being run within a TTY context is to check that the value of
 * the `process.stdout.isTTY` property is `true`:
 *
 * ```console
 * $ node -p -e "Boolean(process.stdout.isTTY)"
 * true
 * $ node -p -e "Boolean(process.stdout.isTTY)" | cat
 * false
 * ```
 *
 * In most cases, there should be little to no reason for an application to
 * manually create instances of the `tty.ReadStream` and `tty.WriteStream` classes.
 * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/tty.js)
 */
declare module "tty" {
    import * as net from "node:net";
    /**
     * The `tty.isatty()` method returns `true` if the given `fd` is associated with
     * a TTY and `false` if it is not, including whenever `fd` is not a non-negative
     * integer.
     * @since v0.5.8
     * @param fd A numeric file descriptor
     */
    function isatty(fd: number): boolean;
    /**
     * Represents the readable side of a TTY. In normal circumstances `process.stdin` will be the only `tty.ReadStream` instance in a Node.js
     * process and there should be no reason to create additional instances.
     * @since v0.5.8
     */
    class ReadStream extends net.Socket {
        constructor(fd: number, options?: net.SocketConstructorOpts);
        /**
         * A `boolean` that is `true` if the TTY is currently configured to operate as a
         * raw device.
         *
         * This flag is always `false` when a process starts, even if the terminal is
         * operating in raw mode. Its value will change with subsequent calls to `setRawMode`.
         * @since v0.7.7
         */
        isRaw: boolean;
        /**
         * Allows configuration of `tty.ReadStream` so that it operates as a raw device.
         *
         * When in raw mode, input is always available character-by-character, not
         * including modifiers. Additionally, all special processing of characters by the
         * terminal is disabled, including echoing input
         * characters. Ctrl+C will no longer cause a `SIGINT` when
         * in this mode.
         * @since v0.7.7
         * @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw`
         * property will be set to the resulting mode.
         * @return The read stream instance.
         */
        setRawMode(mode: boolean): this;
        /**
         * A `boolean` that is always `true` for `tty.ReadStream` instances.
         * @since v0.5.8
         */
        isTTY: boolean;
    }
    /**
     * -1 - to the left from cursor
     *  0 - the entire line
     *  1 - to the right from cursor
     */
    type Direction = -1 | 0 | 1;
    /**
     * Represents the writable side of a TTY. In normal circumstances, `process.stdout` and `process.stderr` will be the only`tty.WriteStream` instances created for a Node.js process and there
     * should be no reason to create additional instances.
     * @since v0.5.8
     */
    class WriteStream extends net.Socket {
        constructor(fd: number);
        addListener(event: string, listener: (...args: any[]) => void): this;
        addListener(event: "resize", listener: () => void): this;
        emit(event: string | symbol, ...args: any[]): boolean;
        emit(event: "resize"): boolean;
        on(event: string, listener: (...args: any[]) => void): this;
        on(event: "resize", listener: () => void): this;
        once(event: string, listener: (...args: any[]) => void): this;
        once(event: "resize", listener: () => void): this;
        prependListener(event: string, listener: (...args: any[]) => void): this;
        prependListener(event: "resize", listener: () => void): this;
        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
        prependOnceListener(event: "resize", listener: () => void): this;
        /**
         * `writeStream.clearLine()` clears the current line of this `WriteStream` in a
         * direction identified by `dir`.
         * @since v0.7.7
         * @param callback Invoked once the operation completes.
         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
         */
        clearLine(dir: Direction, callback?: () => void): boolean;
        /**
         * `writeStream.clearScreenDown()` clears this `WriteStream` from the current
         * cursor down.
         * @since v0.7.7
         * @param callback Invoked once the operation completes.
         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
         */
        clearScreenDown(callback?: () => void): boolean;
        /**
         * `writeStream.cursorTo()` moves this `WriteStream`'s cursor to the specified
         * position.
         * @since v0.7.7
         * @param callback Invoked once the operation completes.
         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
         */
        cursorTo(x: number, y?: number, callback?: () => void): boolean;
        cursorTo(x: number, callback: () => void): boolean;
        /**
         * `writeStream.moveCursor()` moves this `WriteStream`'s cursor _relative_ to its
         * current position.
         * @since v0.7.7
         * @param callback Invoked once the operation completes.
         * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
         */
        moveCursor(dx: number, dy: number, callback?: () => void): boolean;
        /**
         * Returns:
         *
         * * `1` for 2,
         * * `4` for 16,
         * * `8` for 256,
         * * `24` for 16,777,216 colors supported.
         *
         * Use this to determine what colors the terminal supports. Due to the nature of
         * colors in terminals it is possible to either have false positives or false
         * negatives. It depends on process information and the environment variables that
         * may lie about what terminal is used.
         * It is possible to pass in an `env` object to simulate the usage of a specific
         * terminal. This can be useful to check how specific environment settings behave.
         *
         * To enforce a specific color support, use one of the below environment settings.
         *
         * * 2 colors: `FORCE_COLOR = 0` (Disables colors)
         * * 16 colors: `FORCE_COLOR = 1`
         * * 256 colors: `FORCE_COLOR = 2`
         * * 16,777,216 colors: `FORCE_COLOR = 3`
         *
         * Disabling color support is also possible by using the `NO_COLOR` and `NODE_DISABLE_COLORS` environment variables.
         * @since v9.9.0
         * @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
         */
        getColorDepth(env?: object): number;
        /**
         * Returns `true` if the `writeStream` supports at least as many colors as provided
         * in `count`. Minimum support is 2 (black and white).
         *
         * This has the same false positives and negatives as described in `writeStream.getColorDepth()`.
         *
         * ```js
         * process.stdout.hasColors();
         * // Returns true or false depending on if `stdout` supports at least 16 colors.
         * process.stdout.hasColors(256);
         * // Returns true or false depending on if `stdout` supports at least 256 colors.
         * process.stdout.hasColors({ TMUX: '1' });
         * // Returns true.
         * process.stdout.hasColors(2 ** 24, { TMUX: '1' });
         * // Returns false (the environment setting pretends to support 2 ** 8 colors).
         * ```
         * @since v11.13.0, v10.16.0
         * @param [count=16] The number of colors that are requested (minimum 2).
         * @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
         */
        hasColors(count?: number): boolean;
        hasColors(env?: object): boolean;
        hasColors(count: number, env?: object): boolean;
        /**
         * `writeStream.getWindowSize()` returns the size of the TTY
         * corresponding to this `WriteStream`. The array is of the type `[numColumns, numRows]` where `numColumns` and `numRows` represent the number
         * of columns and rows in the corresponding TTY.
         * @since v0.7.7
         */
        getWindowSize(): [number, number];
        /**
         * A `number` specifying the number of columns the TTY currently has. This property
         * is updated whenever the `'resize'` event is emitted.
         * @since v0.7.7
         */
        columns: number;
        /**
         * A `number` specifying the number of rows the TTY currently has. This property
         * is updated whenever the `'resize'` event is emitted.
         * @since v0.7.7
         */
        rows: number;
        /**
         * A `boolean` that is always `true`.
         * @since v0.5.8
         */
        isTTY: boolean;
    }
}
declare module "node:tty" {
    export * from "tty";
}
=== END FILE ===
=== START FILE: ./node_modules/@types/node/zlib.d.ts ===
/**
 * The `node:zlib` module provides compression functionality implemented using
 * Gzip, Deflate/Inflate, and Brotli.
 *
 * To access it:
 *
 * ```js
 * import zlib from 'node:zlib';
 * ```
 *
 * Compression and decompression are built around the Node.js
 * [Streams API](https://nodejs.org/docs/latest-v22.x/api/stream.html).
 *
 * Compressing or decompressing a stream (such as a file) can be accomplished by
 * piping the source stream through a `zlib` `Transform` stream into a destination
 * stream:
 *
 * ```js
 * import { createGzip } from 'node:zlib';
 * import { pipeline } from 'node:stream';
 * import {
 *   createReadStream,
 *   createWriteStream,
 * } from 'node:fs';
 *
 * const gzip = createGzip();
 * const source = createReadStream('input.txt');
 * const destination = createWriteStream('input.txt.gz');
 *
 * pipeline(source, gzip, destination, (err) => {
 *   if (err) {
 *     console.error('An error occurred:', err);
 *     process.exitCode = 1;
 *   }
 * });
 *
 * // Or, Promisified
 *
 * import { promisify } from 'node:util';
 * const pipe = promisify(pipeline);
 *
 * async function do_gzip(input, output) {
 *   const gzip = createGzip();
 *   const source = createReadStream(input);
 *   const destination = createWriteStream(output);
 *   await pipe(source, gzip, destination);
 * }
 *
 * do_gzip('input.txt', 'input.txt.gz')
 *   .catch((err) => {
 *     console.error('An error occurred:', err);
 *     process.exitCode = 1;
 *   });
 * ```
 *
 * It is also possible to compress or decompress data in a single step:
 *
 * ```js
 * import { deflate, unzip } from 'node:zlib';
 *
 * const input = '.................................';
 * deflate(input, (err, buffer) => {
 *   if (err) {
 *     console.error('An error occurred:', err);
 *     process.exitCode = 1;
 *   }
 *   console.log(buffer.toString('base64'));
 * });
 *
 * const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');
 * unzip(buffer, (err, buffer) => {
 *   if (err) {
 *     console.error('An error occurred:', err);
 *     process.exitCode = 1;
 *   }
 *   console.log(buffer.toString());
 * });
 *
 * // Or, Promisified
 *
 * import { promisify } from 'node:util';
 * const do_unzip = promisify(unzip);
 *
 * do_unzip(buffer)
 *   .then((buf) => console.log(buf.toString()))
 *   .catch((err) => {
 *     console.error('An error occurred:', err);
 *     process.exitCode = 1;
 *   });
 * ```
 * @since v0.5.8
 * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/zlib.js)
 */
declare module "zlib" {
    import * as stream from "node:stream";
    interface ZlibOptions {
        /**
         * @default constants.Z_NO_FLUSH
         */
        flush?: number | undefined;
        /**
         * @default constants.Z_FINISH
         */
        finishFlush?: number | undefined;
        /**
         * @default 16*1024
         */
        chunkSize?: number | undefined;
        windowBits?: number | undefined;
        level?: number | undefined; // compression only
        memLevel?: number | undefined; // compression only
        strategy?: number | undefined; // compression only
        dictionary?: NodeJS.ArrayBufferView | ArrayBuffer | undefined; // deflate/inflate only, empty dictionary by default
        /**
         * If `true`, returns an object with `buffer` and `engine`.
         */
        info?: boolean | undefined;
        /**
         * Limits output size when using convenience methods.
         * @default buffer.kMaxLength
         */
        maxOutputLength?: number | undefined;
    }
    interface BrotliOptions {
        /**
         * @default constants.BROTLI_OPERATION_PROCESS
         */
        flush?: number | undefined;
        /**
         * @default constants.BROTLI_OPERATION_FINISH
         */
        finishFlush?: number | undefined;
        /**
         * @default 16*1024
         */
        chunkSize?: number | undefined;
        params?:
            | {
                /**
                 * Each key is a `constants.BROTLI_*` constant.
                 */
                [key: number]: boolean | number;
            }
            | undefined;
        /**
         * Limits output size when using [convenience methods](https://nodejs.org/docs/latest-v22.x/api/zlib.html#convenience-methods).
         * @default buffer.kMaxLength
         */
        maxOutputLength?: number | undefined;
    }
    interface Zlib {
        /** @deprecated Use bytesWritten instead. */
        readonly bytesRead: number;
        readonly bytesWritten: number;
        shell?: boolean | string | undefined;
        close(callback?: () => void): void;
        flush(kind?: number, callback?: () => void): void;
        flush(callback?: () => void): void;
    }
    interface ZlibParams {
        params(level: number, strategy: number, callback: () => void): void;
    }
    interface ZlibReset {
        reset(): void;
    }
    interface BrotliCompress extends stream.Transform, Zlib {}
    interface BrotliDecompress extends stream.Transform, Zlib {}
    interface Gzip extends stream.Transform, Zlib {}
    interface Gunzip extends stream.Transform, Zlib {}
    interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
    interface Inflate extends stream.Transform, Zlib, ZlibReset {}
    interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
    interface InflateRaw extends stream.Transform, Zlib, ZlibReset {}
    interface Unzip extends stream.Transform, Zlib {}
    /**
     * Computes a 32-bit [Cyclic Redundancy Check](https://en.wikipedia.org/wiki/Cyclic_redundancy_check) checksum of `data`.
     * If `value` is specified, it is used as the starting value of the checksum, otherwise, 0 is used as the starting value.
     * @param data When `data` is a string, it will be encoded as UTF-8 before being used for computation.
     * @param value An optional starting value. It must be a 32-bit unsigned integer. @default 0
     * @returns A 32-bit unsigned integer containing the checksum.
     * @since v22.2.0
     */
    function crc32(data: string | Buffer | NodeJS.ArrayBufferView, value?: number): number;
    /**
     * Creates and returns a new `BrotliCompress` object.
     * @since v11.7.0, v10.16.0
     */
    function createBrotliCompress(options?: BrotliOptions): BrotliCompress;
    /**
     * Creates and returns a new `BrotliDecompress` object.
     * @since v11.7.0, v10.16.0
     */
    function createBrotliDecompress(options?: BrotliOptions): BrotliDecompress;
    /**
     * Creates and returns a new `Gzip` object.
     * See `example`.
     * @since v0.5.8
     */
    function createGzip(options?: ZlibOptions): Gzip;
    /**
     * Creates and returns a new `Gunzip` object.
     * @since v0.5.8
     */
    function createGunzip(options?: ZlibOptions): Gunzip;
    /**
     * Creates and returns a new `Deflate` object.
     * @since v0.5.8
     */
    function createDeflate(options?: ZlibOptions): Deflate;
    /**
     * Creates and returns a new `Inflate` object.
     * @since v0.5.8
     */
    function createInflate(options?: ZlibOptions): Inflate;
    /**
     * Creates and returns a new `DeflateRaw` object.
     *
     * An upgrade of zlib from 1.2.8 to 1.2.11 changed behavior when `windowBits` is set to 8 for raw deflate streams. zlib would automatically set `windowBits` to 9 if was initially set to 8. Newer
     * versions of zlib will throw an exception,
     * so Node.js restored the original behavior of upgrading a value of 8 to 9,
     * since passing `windowBits = 9` to zlib actually results in a compressed stream
     * that effectively uses an 8-bit window only.
     * @since v0.5.8
     */
    function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
    /**
     * Creates and returns a new `InflateRaw` object.
     * @since v0.5.8
     */
    function createInflateRaw(options?: ZlibOptions): InflateRaw;
    /**
     * Creates and returns a new `Unzip` object.
     * @since v0.5.8
     */
    function createUnzip(options?: ZlibOptions): Unzip;
    type InputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
    type CompressCallback = (error: Error | null, result: Buffer) => void;
    /**
     * @since v11.7.0, v10.16.0
     */
    function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
    function brotliCompress(buf: InputType, callback: CompressCallback): void;
    namespace brotliCompress {
        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
    }
    /**
     * Compress a chunk of data with `BrotliCompress`.
     * @since v11.7.0, v10.16.0
     */
    function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
    /**
     * @since v11.7.0, v10.16.0
     */
    function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
    function brotliDecompress(buf: InputType, callback: CompressCallback): void;
    namespace brotliDecompress {
        function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
    }
    /**
     * Decompress a chunk of data with `BrotliDecompress`.
     * @since v11.7.0, v10.16.0
     */
    function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function deflate(buf: InputType, callback: CompressCallback): void;
    function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace deflate {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Compress a chunk of data with `Deflate`.
     * @since v0.11.12
     */
    function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function deflateRaw(buf: InputType, callback: CompressCallback): void;
    function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace deflateRaw {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Compress a chunk of data with `DeflateRaw`.
     * @since v0.11.12
     */
    function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function gzip(buf: InputType, callback: CompressCallback): void;
    function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace gzip {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Compress a chunk of data with `Gzip`.
     * @since v0.11.12
     */
    function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function gunzip(buf: InputType, callback: CompressCallback): void;
    function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace gunzip {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Decompress a chunk of data with `Gunzip`.
     * @since v0.11.12
     */
    function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function inflate(buf: InputType, callback: CompressCallback): void;
    function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace inflate {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Decompress a chunk of data with `Inflate`.
     * @since v0.11.12
     */
    function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function inflateRaw(buf: InputType, callback: CompressCallback): void;
    function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace inflateRaw {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Decompress a chunk of data with `InflateRaw`.
     * @since v0.11.12
     */
    function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
    /**
     * @since v0.6.0
     */
    function unzip(buf: InputType, callback: CompressCallback): void;
    function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
    namespace unzip {
        function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
    }
    /**
     * Decompress a chunk of data with `Unzip`.
     * @since v0.11.12
     */
    function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
    namespace constants {
        const BROTLI_DECODE: number;
        const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;
        const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: number;
        const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: number;
        const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: number;
        const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: number;
        const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: number;
        const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: number;
        const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: number;
        const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: number;
        const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: number;
        const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: number;
        const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: number;
        const BROTLI_DECODER_ERROR_FORMAT_DISTANCE: number;
        const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: number;
        const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: number;
        const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: number;
        const BROTLI_DECODER_ERROR_FORMAT_PADDING_1: number;
        const BROTLI_DECODER_ERROR_FORMAT_PADDING_2: number;
        const BROTLI_DECODER_ERROR_FORMAT_RESERVED: number;
        const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: number;
        const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: number;
        const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: number;
        const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: number;
        const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: number;
        const BROTLI_DECODER_ERROR_UNREACHABLE: number;
        const BROTLI_DECODER_NEEDS_MORE_INPUT: number;
        const BROTLI_DECODER_NEEDS_MORE_OUTPUT: number;
        const BROTLI_DECODER_NO_ERROR: number;
        const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: number;
        const BROTLI_DECODER_PARAM_LARGE_WINDOW: number;
        const BROTLI_DECODER_RESULT_ERROR: number;
        const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: number;
        const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number;
        const BROTLI_DECODER_RESULT_SUCCESS: number;
        const BROTLI_DECODER_SUCCESS: number;
        const BROTLI_DEFAULT_MODE: number;
        const BROTLI_DEFAULT_QUALITY: number;
        const BROTLI_DEFAULT_WINDOW: number;
        const BROTLI_ENCODE: number;
        const BROTLI_LARGE_MAX_WINDOW_BITS: number;
        const BROTLI_MAX_INPUT_BLOCK_BITS: number;
        const BROTLI_MAX_QUALITY: number;
        const BROTLI_MAX_WINDOW_BITS: number;
        const BROTLI_MIN_INPUT_BLOCK_BITS: number;
        const BROTLI_MIN_QUALITY: number;
        const BROTLI_MIN_WINDOW_BITS: number;
        const BROTLI_MODE_FONT: number;
        const BROTLI_MODE_GENERIC: number;
        const BROTLI_MODE_TEXT: number;
        const BROTLI_OPERATION_EMIT_METADATA: number;
        const BROTLI_OPERATION_FINISH: number;
        const BROTLI_OPERATION_FLUSH: number;
        const BROTLI_OPERATION_PROCESS: number;
        const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number;
        const BROTLI_PARAM_LARGE_WINDOW: number;
        const BROTLI_PARAM_LGBLOCK: number;
        const BROTLI_PARAM_LGWIN: number;
        const BROTLI_PARAM_MODE: number;
        const BROTLI_PARAM_NDIRECT: number;
        const BROTLI_PARAM_NPOSTFIX: number;
        const BROTLI_PARAM_QUALITY: number;
        const BROTLI_PARAM_SIZE_HINT: number;
        const DEFLATE: number;
        const DEFLATERAW: number;
        const GUNZIP: number;
        const GZIP: number;
        const INFLATE: number;
        const INFLATERAW: number;
        const UNZIP: number;
        // Allowed flush values.
        const Z_NO_FLUSH: number;
        const Z_PARTIAL_FLUSH: number;
        const Z_SYNC_FLUSH: number;
        const Z_FULL_FLUSH: number;
        const Z_FINISH: number;
        const Z_BLOCK: number;
        const Z_TREES: number;
        // Return codes for the compression/decompression functions.
        // Negative values are errors, positive values are used for special but normal events.
        const Z_OK: number;
        const Z_STREAM_END: number;
        const Z_NEED_DICT: number;
        const Z_ERRNO: number;
        const Z_STREAM_ERROR: number;
        const Z_DATA_ERROR: number;
        const Z_MEM_ERROR: number;
        const Z_BUF_ERROR: number;
        const Z_VERSION_ERROR: number;
        // Compression levels.
        const Z_NO_COMPRESSION: number;
        const Z_BEST_SPEED: number;
        const Z_BEST_COMPRESSION: number;
        const Z_DEFAULT_COMPRESSION: number;
        // Compression strategy.
        const Z_FILTERED: number;
        const Z_HUFFMAN_ONLY: number;
        const Z_RLE: number;
        const Z_FIXED: number;
        const Z_DEFAULT_STRATEGY: number;
        const Z_DEFAULT_WINDOWBITS: number;

        const Z_MIN_WINDOWBITS: number;
        const Z_MAX_WINDOWBITS: number;
        const Z_MIN_CHUNK: number;
        const Z_MAX_CHUNK: number;
        const Z_DEFAULT_CHUNK: number;
        const Z_MIN_MEMLEVEL: number;
        const Z_MAX_MEMLEVEL: number;
        const Z_DEFAULT_MEMLEVEL: number;
        const Z_MIN_LEVEL: number;
        const Z_MAX_LEVEL: number;
        const Z_DEFAULT_LEVEL: number;
        const ZLIB_VERNUM: number;
    }
    // Allowed flush values.
    /** @deprecated Use `constants.Z_NO_FLUSH` */
    const Z_NO_FLUSH: number;
    /** @deprecated Use `constants.Z_PARTIAL_FLUSH` */
    const Z_PARTIAL_FLUSH: number;
    /** @deprecated Use `constants.Z_SYNC_FLUSH` */
    const Z_SYNC_FLUSH: number;
    /** @deprecated Use `constants.Z_FULL_FLUSH` */
    const Z_FULL_FLUSH: number;
    /** @deprecated Use `constants.Z_FINISH` */
    const Z_FINISH: number;
    /** @deprecated Use `constants.Z_BLOCK` */
    const Z_BLOCK: number;
    /** @deprecated Use `constants.Z_TREES` */
    const Z_TREES: number;
    // Return codes for the compression/decompression functions.
    // Negative values are errors, positive values are used for special but normal events.
    /** @deprecated Use `constants.Z_OK` */
    const Z_OK: number;
    /** @deprecated Use `constants.Z_STREAM_END` */
    const Z_STREAM_END: number;
    /** @deprecated Use `constants.Z_NEED_DICT` */
    const Z_NEED_DICT: number;
    /** @deprecated Use `constants.Z_ERRNO` */
    const Z_ERRNO: number;
    /** @deprecated Use `constants.Z_STREAM_ERROR` */
    const Z_STREAM_ERROR: number;
    /** @deprecated Use `constants.Z_DATA_ERROR` */
    const Z_DATA_ERROR: number;
    /** @deprecated Use `constants.Z_MEM_ERROR` */
    const Z_MEM_ERROR: number;
    /** @deprecated Use `constants.Z_BUF_ERROR` */
    const Z_BUF_ERROR: number;
    /** @deprecated Use `constants.Z_VERSION_ERROR` */
    const Z_VERSION_ERROR: number;
    // Compression levels.
    /** @deprecated Use `constants.Z_NO_COMPRESSION` */
    const Z_NO_COMPRESSION: number;
    /** @deprecated Use `constants.Z_BEST_SPEED` */
    const Z_BEST_SPEED: number;
    /** @deprecated Use `constants.Z_BEST_COMPRESSION` */
    const Z_BEST_COMPRESSION: number;
    /** @deprecated Use `constants.Z_DEFAULT_COMPRESSION` */
    const Z_DEFAULT_COMPRESSION: number;
    // Compression strategy.
    /** @deprecated Use `constants.Z_FILTERED` */
    const Z_FILTERED: number;
    /** @deprecated Use `constants.Z_HUFFMAN_ONLY` */
    const Z_HUFFMAN_ONLY: number;
    /** @deprecated Use `constants.Z_RLE` */
    const Z_RLE: number;
    /** @deprecated Use `constants.Z_FIXED` */
    const Z_FIXED: number;
    /** @deprecated Use `constants.Z_DEFAULT_STRATEGY` */
    const Z_DEFAULT_STRATEGY: number;
    /** @deprecated */
    const Z_BINARY: number;
    /** @deprecated */
    const Z_TEXT: number;
    /** @deprecated */
    const Z_ASCII: number;
    /** @deprecated  */
    const Z_UNKNOWN: number;
    /** @deprecated */
    const Z_DEFLATED: number;
}
declare module "node:zlib" {
    export * from "zlib";
}
=== END FILE ===
=== START FILE: ./node_modules/@types/node/events.d.ts ===
/**
 * Much of the Node.js core API is built around an idiomatic asynchronous
 * event-driven architecture in which certain kinds of objects (called "emitters")
 * emit named events that cause `Function` objects ("listeners") to be called.
 *
 * For instance: a `net.Server` object emits an event each time a peer
 * connects to it; a `fs.ReadStream` emits an event when the file is opened;
 * a `stream` emits an event whenever data is available to be read.
 *
 * All objects that emit events are instances of the `EventEmitter` class. These
 * objects expose an `eventEmitter.on()` function that allows one or more
 * functions to be attached to named events emitted by the object. Typically,
 * event names are camel-cased strings but any valid JavaScript property key
 * can be used.
 *
 * When the `EventEmitter` object emits an event, all of the functions attached
 * to that specific event are called _synchronously_. Any values returned by the
 * called listeners are _ignored_ and discarded.
 *
 * The following example shows a simple `EventEmitter` instance with a single
 * listener. The `eventEmitter.on()` method is used to register listeners, while
 * the `eventEmitter.emit()` method is used to trigger the event.
 *
 * ```js
 * import { EventEmitter } from 'node:events';
 *
 * class MyEmitter extends EventEmitter {}
 *
 * const myEmitter = new MyEmitter();
 * myEmitter.on('event', () => {
 *   console.log('an event occurred!');
 * });
 * myEmitter.emit('event');
 * ```
 * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/events.js)
 */
declare module "events" {
    import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
    // NOTE: This class is in the docs but is **not actually exported** by Node.
    // If https://github.com/nodejs/node/issues/39903 gets resolved and Node
    // actually starts exporting the class, uncomment below.
    // import { EventListener, EventListenerObject } from '__dom-events';
    // /** The NodeEventTarget is a Node.js-specific extension to EventTarget that emulates a subset of the EventEmitter API. */
    // interface NodeEventTarget extends EventTarget {
    //     /**
    //      * Node.js-specific extension to the `EventTarget` class that emulates the equivalent `EventEmitter` API.
    //      * The only difference between `addListener()` and `addEventListener()` is that addListener() will return a reference to the EventTarget.
    //      */
    //     addListener(type: string, listener: EventListener | EventListenerObject, options?: { once: boolean }): this;
    //     /** Node.js-specific extension to the `EventTarget` class that returns an array of event `type` names for which event listeners are registered. */
    //     eventNames(): string[];
    //     /** Node.js-specific extension to the `EventTarget` class that returns the number of event listeners registered for the `type`. */
    //     listenerCount(type: string): number;
    //     /** Node.js-specific alias for `eventTarget.removeListener()`. */
    //     off(type: string, listener: EventListener | EventListenerObject): this;
    //     /** Node.js-specific alias for `eventTarget.addListener()`. */
    //     on(type: string, listener: EventListener | EventListenerObject, options?: { once: boolean }): this;
    //     /** Node.js-specific extension to the `EventTarget` class that adds a `once` listener for the given event `type`. This is equivalent to calling `on` with the `once` option set to `true`. */
    //     once(type: string, listener: EventListener | EventListenerObject): this;
    //     /**
    //      * Node.js-specific extension to the `EventTarget` class.
    //      * If `type` is specified, removes all registered listeners for `type`,
    //      * otherwise removes all registered listeners.
    //      */
    //     removeAllListeners(type: string): this;
    //     /**
    //      * Node.js-specific extension to the `EventTarget` class that removes the listener for the given `type`.
    //      * The only difference between `removeListener()` and `removeEventListener()` is that `removeListener()` will return a reference to the `EventTarget`.
    //      */
    //     removeListener(type: string, listener: EventListener | EventListenerObject): this;
    // }
    interface EventEmitterOptions {
        /**
         * Enables automatic capturing of promise rejection.
         */
        captureRejections?: boolean | undefined;
    }
    interface StaticEventEmitterOptions {
        /**
         * Can be used to cancel awaiting events.
         */
        signal?: AbortSignal | undefined;
    }
    interface StaticEventEmitterIteratorOptions extends StaticEventEmitterOptions {
        /**
         * Names of events that will end the iteration.
         */
        close?: string[] | undefined;
        /**
         * The high watermark. The emitter is paused every time the size of events being buffered is higher than it.
         * Supported only on emitters implementing `pause()` and `resume()` methods.
         * @default Number.MAX_SAFE_INTEGER
         */
        highWaterMark?: number | undefined;
        /**
         * The low watermark. The emitter is resumed every time the size of events being buffered is lower than it.
         * Supported only on emitters implementing `pause()` and `resume()` methods.
         * @default 1
         */
        lowWaterMark?: number | undefined;
    }
    interface EventEmitter<T extends EventMap<T> = DefaultEventMap> extends NodeJS.EventEmitter<T> {}
    type EventMap<T> = Record<keyof T, any[]> | DefaultEventMap;
    type DefaultEventMap = [never];
    type AnyRest = [...args: any[]];
    type Args<K, T> = T extends DefaultEventMap ? AnyRest : (
        K extends keyof T ? T[K] : never
    );
    type Key<K, T> = T extends DefaultEventMap ? string | symbol : K | keyof T;
    type Key2<K, T> = T extends DefaultEventMap ? string | symbol : K & keyof T;
    type Listener<K, T, F> = T extends DefaultEventMap ? F : (
        K extends keyof T ? (
                T[K] extends unknown[] ? (...args: T[K]) => void : never
            )
            : never
    );
    type Listener1<K, T> = Listener<K, T, (...args: any[]) => void>;
    type Listener2<K, T> = Listener<K, T, Function>;

    /**
     * The `EventEmitter` class is defined and exposed by the `node:events` module:
     *
     * ```js
     * import { EventEmitter } from 'node:events';
     * ```
     *
     * All `EventEmitter`s emit the event `'newListener'` when new listeners are
     * added and `'removeListener'` when existing listeners are removed.
     *
     * It supports the following option:
     * @since v0.1.26
     */
    class EventEmitter<T extends EventMap<T> = DefaultEventMap> {
        constructor(options?: EventEmitterOptions);

        [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;

        /**
         * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
         * event or that is rejected if the `EventEmitter` emits `'error'` while waiting.
         * The `Promise` will resolve with an array of all the arguments emitted to the
         * given event.
         *
         * This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
         * semantics and does not listen to the `'error'` event.
         *
         * ```js
         * import { once, EventEmitter } from 'node:events';
         * import process from 'node:process';
         *
         * const ee = new EventEmitter();
         *
         * process.nextTick(() => {
         *   ee.emit('myevent', 42);
         * });
         *
         * const [value] = await once(ee, 'myevent');
         * console.log(value);
         *
         * const err = new Error('kaboom');
         * process.nextTick(() => {
         *   ee.emit('error', err);
         * });
         *
         * try {
         *   await once(ee, 'myevent');
         * } catch (err) {
         *   console.error('error happened', err);
         * }
         * ```
         *
         * The special handling of the `'error'` event is only used when `events.once()` is used to wait for another event. If `events.once()` is used to wait for the
         * '`error'` event itself, then it is treated as any other kind of event without
         * special handling:
         *
         * ```js
         * import { EventEmitter, once } from 'node:events';
         *
         * const ee = new EventEmitter();
         *
         * once(ee, 'error')
         *   .then(([err]) => console.log('ok', err.message))
         *   .catch((err) => console.error('error', err.message));
         *
         * ee.emit('error', new Error('boom'));
         *
         * // Prints: ok boom
         * ```
         *
         * An `AbortSignal` can be used to cancel waiting for the event:
         *
         * ```js
         * import { EventEmitter, once } from 'node:events';
         *
         * const ee = new EventEmitter();
         * const ac = new AbortController();
         *
         * async function foo(emitter, event, signal) {
         *   try {
         *     await once(emitter, event, { signal });
         *     console.log('event emitted!');
         *   } catch (error) {
         *     if (error.name === 'AbortError') {
         *       console.error('Waiting for the event was canceled!');
         *     } else {
         *       console.error('There was an error', error.message);
         *     }
         *   }
         * }
         *
         * foo(ee, 'foo', ac.signal);
         * ac.abort(); // Abort waiting for the event
         * ee.emit('foo'); // Prints: Waiting for the event was canceled!
         * ```
         * @since v11.13.0, v10.16.0
         */
        static once(
            emitter: NodeJS.EventEmitter,
            eventName: string | symbol,
            options?: StaticEventEmitterOptions,
        ): Promise<any[]>;
        static once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
        /**
         * ```js
         * import { on, EventEmitter } from 'node:events';
         * import process from 'node:process';
         *
         * const ee = new EventEmitter();
         *
         * // Emit later on
         * process.nextTick(() => {
         *   ee.emit('foo', 'bar');
         *   ee.emit('foo', 42);
         * });
         *
         * for await (const event of on(ee, 'foo')) {
         *   // The execution of this inner block is synchronous and it
         *   // processes one event at a time (even with await). Do not use
         *   // if concurrent execution is required.
         *   console.log(event); // prints ['bar'] [42]
         * }
         * // Unreachable here
         * ```
         *
         * Returns an `AsyncIterator` that iterates `eventName` events. It will throw
         * if the `EventEmitter` emits `'error'`. It removes all listeners when
         * exiting the loop. The `value` returned by each iteration is an array
         * composed of the emitted event arguments.
         *
         * An `AbortSignal` can be used to cancel waiting on events:
         *
         * ```js
         * import { on, EventEmitter } from 'node:events';
         * import process from 'node:process';
         *
         * const ac = new AbortController();
         *
         * (async () => {
         *   const ee = new EventEmitter();
         *
         *   // Emit later on
         *   process.nextTick(() => {
         *     ee.emit('foo', 'bar');
         *     ee.emit('foo', 42);
         *   });
         *
         *   for await (const event of on(ee, 'foo', { signal: ac.signal })) {
         *     // The execution of this inner block is synchronous and it
         *     // processes one event at a time (even with await). Do not use
         *     // if concurrent execution is required.
         *     console.log(event); // prints ['bar'] [42]
         *   }
         *   // Unreachable here
         * })();
         *
         * process.nextTick(() => ac.abort());
         * ```
         *
         * Use the `close` option to specify an array of event names that will end the iteration:
         *
         * ```js
         * import { on, EventEmitter } from 'node:events';
         * import process from 'node:process';
         *
         * const ee = new EventEmitter();
         *
         * // Emit later on
         * process.nextTick(() => {
         *   ee.emit('foo', 'bar');
         *   ee.emit('foo', 42);
         *   ee.emit('close');
         * });
         *
         * for await (const event of on(ee, 'foo', { close: ['close'] })) {
         *   console.log(event); // prints ['bar'] [42]
         * }
         * // the loop will exit after 'close' is emitted
         * console.log('done'); // prints 'done'
         * ```
         * @since v13.6.0, v12.16.0
         * @return An `AsyncIterator` that iterates `eventName` events emitted by the `emitter`
         */
        static on(
            emitter: NodeJS.EventEmitter,
            eventName: string | symbol,
            options?: StaticEventEmitterIteratorOptions,
        ): NodeJS.AsyncIterator<any[]>;
        static on(
            emitter: EventTarget,
            eventName: string,
            options?: StaticEventEmitterIteratorOptions,
        ): NodeJS.AsyncIterator<any[]>;
        /**
         * A class method that returns the number of listeners for the given `eventName` registered on the given `emitter`.
         *
         * ```js
         * import { EventEmitter, listenerCount } from 'node:events';
         *
         * const myEmitter = new EventEmitter();
         * myEmitter.on('event', () => {});
         * myEmitter.on('event', () => {});
         * console.log(listenerCount(myEmitter, 'event'));
         * // Prints: 2
         * ```
         * @since v0.9.12
         * @deprecated Since v3.2.0 - Use `listenerCount` instead.
         * @param emitter The emitter to query
         * @param eventName The event name
         */
        static listenerCount(emitter: NodeJS.EventEmitter, eventName: string | symbol): number;
        /**
         * Returns a copy of the array of listeners for the event named `eventName`.
         *
         * For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
         * the emitter.
         *
         * For `EventTarget`s this is the only way to get the event listeners for the
         * event target. This is useful for debugging and diagnostic purposes.
         *
         * ```js
         * import { getEventListeners, EventEmitter } from 'node:events';
         *
         * {
         *   const ee = new EventEmitter();
         *   const listener = () => console.log('Events are fun');
         *   ee.on('foo', listener);
         *   console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
         * }
         * {
         *   const et = new EventTarget();
         *   const listener = () => console.log('Events are fun');
         *   et.addEventListener('foo', listener);
         *   console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
         * }
         * ```
         * @since v15.2.0, v14.17.0
         */
        static getEventListeners(emitter: EventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
        /**
         * Returns the currently set max amount of listeners.
         *
         * For `EventEmitter`s this behaves exactly the same as calling `.getMaxListeners` on
         * the emitter.
         *
         * For `EventTarget`s this is the only way to get the max event listeners for the
         * event target. If the number of event handlers on a single EventTarget exceeds
         * the max set, the EventTarget will print a warning.
         *
         * ```js
         * import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';
         *
         * {
         *   const ee = new EventEmitter();
         *   console.log(getMaxListeners(ee)); // 10
         *   setMaxListeners(11, ee);
         *   console.log(getMaxListeners(ee)); // 11
         * }
         * {
         *   const et = new EventTarget();
         *   console.log(getMaxListeners(et)); // 10
         *   setMaxListeners(11, et);
         *   console.log(getMaxListeners(et)); // 11
         * }
         * ```
         * @since v19.9.0
         */
        static getMaxListeners(emitter: EventTarget | NodeJS.EventEmitter): number;
        /**
         * ```js
         * import { setMaxListeners, EventEmitter } from 'node:events';
         *
         * const target = new EventTarget();
         * const emitter = new EventEmitter();
         *
         * setMaxListeners(5, target, emitter);
         * ```
         * @since v15.4.0
         * @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
         * @param eventTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
         * objects.
         */
        static setMaxListeners(n?: number, ...eventTargets: Array<EventTarget | NodeJS.EventEmitter>): void;
        /**
         * Listens once to the `abort` event on the provided `signal`.
         *
         * Listening to the `abort` event on abort signals is unsafe and may
         * lead to resource leaks since another third party with the signal can
         * call `e.stopImmediatePropagation()`. Unfortunately Node.js cannot change
         * this since it would violate the web standard. Additionally, the original
         * API makes it easy to forget to remove listeners.
         *
         * This API allows safely using `AbortSignal`s in Node.js APIs by solving these
         * two issues by listening to the event such that `stopImmediatePropagation` does
         * not prevent the listener from running.
         *
         * Returns a disposable so that it may be unsubscribed from more easily.
         *
         * ```js
         * import { addAbortListener } from 'node:events';
         *
         * function example(signal) {
         *   let disposable;
         *   try {
         *     signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
         *     disposable = addAbortListener(signal, (e) => {
         *       // Do something when signal is aborted.
         *     });
         *   } finally {
         *     disposable?.[Symbol.dispose]();
         *   }
         * }
         * ```
         * @since v20.5.0
         * @experimental
         * @return Disposable that removes the `abort` listener.
         */
        static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
        /**
         * This symbol shall be used to install a listener for only monitoring `'error'` events. Listeners installed using this symbol are called before the regular `'error'` listeners are called.
         *
         * Installing a listener using this symbol does not change the behavior once an `'error'` event is emitted. Therefore, the process will still crash if no
         * regular `'error'` listener is installed.
         * @since v13.6.0, v12.17.0
         */
        static readonly errorMonitor: unique symbol;
        /**
         * Value: `Symbol.for('nodejs.rejection')`
         *
         * See how to write a custom `rejection handler`.
         * @since v13.4.0, v12.16.0
         */
        static readonly captureRejectionSymbol: unique symbol;
        /**
         * Value: [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type)
         *
         * Change the default `captureRejections` option on all new `EventEmitter` objects.
         * @since v13.4.0, v12.16.0
         */
        static captureRejections: boolean;
        /**
         * By default, a maximum of `10` listeners can be registered for any single
         * event. This limit can be changed for individual `EventEmitter` instances
         * using the `emitter.setMaxListeners(n)` method. To change the default
         * for _all_`EventEmitter` instances, the `events.defaultMaxListeners` property
         * can be used. If this value is not a positive number, a `RangeError` is thrown.
         *
         * Take caution when setting the `events.defaultMaxListeners` because the
         * change affects _all_ `EventEmitter` instances, including those created before
         * the change is made. However, calling `emitter.setMaxListeners(n)` still has
         * precedence over `events.defaultMaxListeners`.
         *
         * This is not a hard limit. The `EventEmitter` instance will allow
         * more listeners to be added but will output a trace warning to stderr indicating
         * that a "possible EventEmitter memory leak" has been detected. For any single
         * `EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()` methods can be used to
         * temporarily avoid this warning:
         *
         * ```js
         * import { EventEmitter } from 'node:events';
         * const emitter = new EventEmitter();
         * emitter.setMaxListeners(emitter.getMaxListeners() + 1);
         * emitter.once('event', () => {
         *   // do stuff
         *   emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
         * });
         * ```
         *
         * The `--trace-warnings` command-line flag can be used to display the
         * stack trace for such warnings.
         *
         * The emitted warning can be inspected with `process.on('warning')` and will
         * have the additional `emitter`, `type`, and `count` properties, referring to
         * the event emitter instance, the event's name and the number of attached
         * listeners, respectively.
         * Its `name` property is set to `'MaxListenersExceededWarning'`.
         * @since v0.11.2
         */
        static defaultMaxListeners: number;
    }
    import internal = require("node:events");
    namespace EventEmitter {
        // Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
        export { internal as EventEmitter };
        export interface Abortable {
            /**
             * When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
             */
            signal?: AbortSignal | undefined;
        }

        export interface EventEmitterReferencingAsyncResource extends AsyncResource {
            readonly eventEmitter: EventEmitterAsyncResource;
        }

        export interface EventEmitterAsyncResourceOptions extends AsyncResourceOptions, EventEmitterOptions {
            /**
             * The type of async event, this is required when instantiating `EventEmitterAsyncResource`
             * directly rather than as a child class.
             * @default new.target.name if instantiated as a child class.
             */
            name?: string;
        }

        /**
         * Integrates `EventEmitter` with `AsyncResource` for `EventEmitter`s that
         * require manual async tracking. Specifically, all events emitted by instances
         * of `events.EventEmitterAsyncResource` will run within its `async context`.
         *
         * ```js
         * import { EventEmitterAsyncResource, EventEmitter } from 'node:events';
         * import { notStrictEqual, strictEqual } from 'node:assert';
         * import { executionAsyncId, triggerAsyncId } from 'node:async_hooks';
         *
         * // Async tracking tooling will identify this as 'Q'.
         * const ee1 = new EventEmitterAsyncResource({ name: 'Q' });
         *
         * // 'foo' listeners will run in the EventEmitters async context.
         * ee1.on('foo', () => {
         *   strictEqual(executionAsyncId(), ee1.asyncId);
         *   strictEqual(triggerAsyncId(), ee1.triggerAsyncId);
         * });
         *
         * const ee2 = new EventEmitter();
         *
         * // 'foo' listeners on ordinary EventEmitters that do not track async
         * // context, however, run in the same async context as the emit().
         * ee2.on('foo', () => {
         *   notStrictEqual(executionAsyncId(), ee2.asyncId);
         *   notStrictEqual(triggerAsyncId(), ee2.triggerAsyncId);
         * });
         *
         * Promise.resolve().then(() => {
         *   ee1.emit('foo');
         *   ee2.emit('foo');
         * });
         * ```
         *
         * The `EventEmitterAsyncResource` class has the same methods and takes the
         * same options as `EventEmitter` and `AsyncResource` themselves.
         * @since v17.4.0, v16.14.0
         */
        export class EventEmitterAsyncResource extends EventEmitter {
            /**
             * @param options Only optional in child class.
             */
            constructor(options?: EventEmitterAsyncResourceOptions);
            /**
             * Call all `destroy` hooks. This should only ever be called once. An error will
             * be thrown if it is called more than once. This **must** be manually called. If
             * the resource is left to be collected by the GC then the `destroy` hooks will
             * never be called.
             */
            emitDestroy(): void;
            /**
             * The unique `asyncId` assigned to the resource.
             */
            readonly asyncId: number;
            /**
             * The same triggerAsyncId that is passed to the AsyncResource constructor.
             */
            readonly triggerAsyncId: number;
            /**
             * The returned `AsyncResource` object has an additional `eventEmitter` property
             * that provides a reference to this `EventEmitterAsyncResource`.
             */
            readonly asyncResource: EventEmitterReferencingAsyncResource;
        }
    }
    global {
        namespace NodeJS {
            interface EventEmitter<T extends EventMap<T> = DefaultEventMap> {
                [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;
                /**
                 * Alias for `emitter.on(eventName, listener)`.
                 * @since v0.1.26
                 */
                addListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Adds the `listener` function to the end of the listeners array for the event
                 * named `eventName`. No checks are made to see if the `listener` has already
                 * been added. Multiple calls passing the same combination of `eventName` and
                 * `listener` will result in the `listener` being added, and called, multiple times.
                 *
                 * ```js
                 * server.on('connection', (stream) => {
                 *   console.log('someone connected!');
                 * });
                 * ```
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 *
                 * By default, event listeners are invoked in the order they are added. The `emitter.prependListener()` method can be used as an alternative to add the
                 * event listener to the beginning of the listeners array.
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 * const myEE = new EventEmitter();
                 * myEE.on('foo', () => console.log('a'));
                 * myEE.prependListener('foo', () => console.log('b'));
                 * myEE.emit('foo');
                 * // Prints:
                 * //   b
                 * //   a
                 * ```
                 * @since v0.1.101
                 * @param eventName The name of the event.
                 * @param listener The callback function
                 */
                on<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Adds a **one-time** `listener` function for the event named `eventName`. The
                 * next time `eventName` is triggered, this listener is removed and then invoked.
                 *
                 * ```js
                 * server.once('connection', (stream) => {
                 *   console.log('Ah, we have our first user!');
                 * });
                 * ```
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 *
                 * By default, event listeners are invoked in the order they are added. The `emitter.prependOnceListener()` method can be used as an alternative to add the
                 * event listener to the beginning of the listeners array.
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 * const myEE = new EventEmitter();
                 * myEE.once('foo', () => console.log('a'));
                 * myEE.prependOnceListener('foo', () => console.log('b'));
                 * myEE.emit('foo');
                 * // Prints:
                 * //   b
                 * //   a
                 * ```
                 * @since v0.3.0
                 * @param eventName The name of the event.
                 * @param listener The callback function
                 */
                once<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Removes the specified `listener` from the listener array for the event named `eventName`.
                 *
                 * ```js
                 * const callback = (stream) => {
                 *   console.log('someone connected!');
                 * };
                 * server.on('connection', callback);
                 * // ...
                 * server.removeListener('connection', callback);
                 * ```
                 *
                 * `removeListener()` will remove, at most, one instance of a listener from the
                 * listener array. If any single listener has been added multiple times to the
                 * listener array for the specified `eventName`, then `removeListener()` must be
                 * called multiple times to remove each instance.
                 *
                 * Once an event is emitted, all listeners attached to it at the
                 * time of emitting are called in order. This implies that any `removeListener()` or `removeAllListeners()` calls _after_ emitting and _before_ the last listener finishes execution
                 * will not remove them from`emit()` in progress. Subsequent events behave as expected.
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 * class MyEmitter extends EventEmitter {}
                 * const myEmitter = new MyEmitter();
                 *
                 * const callbackA = () => {
                 *   console.log('A');
                 *   myEmitter.removeListener('event', callbackB);
                 * };
                 *
                 * const callbackB = () => {
                 *   console.log('B');
                 * };
                 *
                 * myEmitter.on('event', callbackA);
                 *
                 * myEmitter.on('event', callbackB);
                 *
                 * // callbackA removes listener callbackB but it will still be called.
                 * // Internal listener array at time of emit [callbackA, callbackB]
                 * myEmitter.emit('event');
                 * // Prints:
                 * //   A
                 * //   B
                 *
                 * // callbackB is now removed.
                 * // Internal listener array [callbackA]
                 * myEmitter.emit('event');
                 * // Prints:
                 * //   A
                 * ```
                 *
                 * Because listeners are managed using an internal array, calling this will
                 * change the position indices of any listener registered _after_ the listener
                 * being removed. This will not impact the order in which listeners are called,
                 * but it means that any copies of the listener array as returned by
                 * the `emitter.listeners()` method will need to be recreated.
                 *
                 * When a single function has been added as a handler multiple times for a single
                 * event (as in the example below), `removeListener()` will remove the most
                 * recently added instance. In the example the `once('ping')` listener is removed:
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 * const ee = new EventEmitter();
                 *
                 * function pong() {
                 *   console.log('pong');
                 * }
                 *
                 * ee.on('ping', pong);
                 * ee.once('ping', pong);
                 * ee.removeListener('ping', pong);
                 *
                 * ee.emit('ping');
                 * ee.emit('ping');
                 * ```
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 * @since v0.1.26
                 */
                removeListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Alias for `emitter.removeListener()`.
                 * @since v10.0.0
                 */
                off<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Removes all listeners, or those of the specified `eventName`.
                 *
                 * It is bad practice to remove listeners added elsewhere in the code,
                 * particularly when the `EventEmitter` instance was created by some other
                 * component or module (e.g. sockets or file streams).
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 * @since v0.1.26
                 */
                removeAllListeners(eventName?: Key<unknown, T>): this;
                /**
                 * By default `EventEmitter`s will print a warning if more than `10` listeners are
                 * added for a particular event. This is a useful default that helps finding
                 * memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
                 * modified for this specific `EventEmitter` instance. The value can be set to `Infinity` (or `0`) to indicate an unlimited number of listeners.
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 * @since v0.3.5
                 */
                setMaxListeners(n: number): this;
                /**
                 * Returns the current max listener value for the `EventEmitter` which is either
                 * set by `emitter.setMaxListeners(n)` or defaults to {@link EventEmitter.defaultMaxListeners}.
                 * @since v1.0.0
                 */
                getMaxListeners(): number;
                /**
                 * Returns a copy of the array of listeners for the event named `eventName`.
                 *
                 * ```js
                 * server.on('connection', (stream) => {
                 *   console.log('someone connected!');
                 * });
                 * console.log(util.inspect(server.listeners('connection')));
                 * // Prints: [ [Function] ]
                 * ```
                 * @since v0.1.26
                 */
                listeners<K>(eventName: Key<K, T>): Array<Listener2<K, T>>;
                /**
                 * Returns a copy of the array of listeners for the event named `eventName`,
                 * including any wrappers (such as those created by `.once()`).
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 * const emitter = new EventEmitter();
                 * emitter.once('log', () => console.log('log once'));
                 *
                 * // Returns a new Array with a function `onceWrapper` which has a property
                 * // `listener` which contains the original listener bound above
                 * const listeners = emitter.rawListeners('log');
                 * const logFnWrapper = listeners[0];
                 *
                 * // Logs "log once" to the console and does not unbind the `once` event
                 * logFnWrapper.listener();
                 *
                 * // Logs "log once" to the console and removes the listener
                 * logFnWrapper();
                 *
                 * emitter.on('log', () => console.log('log persistently'));
                 * // Will return a new Array with a single function bound by `.on()` above
                 * const newListeners = emitter.rawListeners('log');
                 *
                 * // Logs "log persistently" twice
                 * newListeners[0]();
                 * emitter.emit('log');
                 * ```
                 * @since v9.4.0
                 */
                rawListeners<K>(eventName: Key<K, T>): Array<Listener2<K, T>>;
                /**
                 * Synchronously calls each of the listeners registered for the event named `eventName`, in the order they were registered, passing the supplied arguments
                 * to each.
                 *
                 * Returns `true` if the event had listeners, `false` otherwise.
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 * const myEmitter = new EventEmitter();
                 *
                 * // First listener
                 * myEmitter.on('event', function firstListener() {
                 *   console.log('Helloooo! first listener');
                 * });
                 * // Second listener
                 * myEmitter.on('event', function secondListener(arg1, arg2) {
                 *   console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
                 * });
                 * // Third listener
                 * myEmitter.on('event', function thirdListener(...args) {
                 *   const parameters = args.join(', ');
                 *   console.log(`event with parameters ${parameters} in third listener`);
                 * });
                 *
                 * console.log(myEmitter.listeners('event'));
                 *
                 * myEmitter.emit('event', 1, 2, 3, 4, 5);
                 *
                 * // Prints:
                 * // [
                 * //   [Function: firstListener],
                 * //   [Function: secondListener],
                 * //   [Function: thirdListener]
                 * // ]
                 * // Helloooo! first listener
                 * // event with parameters 1, 2 in second listener
                 * // event with parameters 1, 2, 3, 4, 5 in third listener
                 * ```
                 * @since v0.1.26
                 */
                emit<K>(eventName: Key<K, T>, ...args: Args<K, T>): boolean;
                /**
                 * Returns the number of listeners listening for the event named `eventName`.
                 * If `listener` is provided, it will return how many times the listener is found
                 * in the list of the listeners of the event.
                 * @since v3.2.0
                 * @param eventName The name of the event being listened for
                 * @param listener The event handler function
                 */
                listenerCount<K>(eventName: Key<K, T>, listener?: Listener2<K, T>): number;
                /**
                 * Adds the `listener` function to the _beginning_ of the listeners array for the
                 * event named `eventName`. No checks are made to see if the `listener` has
                 * already been added. Multiple calls passing the same combination of `eventName`
                 * and `listener` will result in the `listener` being added, and called, multiple times.
                 *
                 * ```js
                 * server.prependListener('connection', (stream) => {
                 *   console.log('someone connected!');
                 * });
                 * ```
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 * @since v6.0.0
                 * @param eventName The name of the event.
                 * @param listener The callback function
                 */
                prependListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array. The next time `eventName` is triggered, this
                 * listener is removed, and then invoked.
                 *
                 * ```js
                 * server.prependOnceListener('connection', (stream) => {
                 *   console.log('Ah, we have our first user!');
                 * });
                 * ```
                 *
                 * Returns a reference to the `EventEmitter`, so that calls can be chained.
                 * @since v6.0.0
                 * @param eventName The name of the event.
                 * @param listener The callback function
                 */
                prependOnceListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                /**
                 * Returns an array listing the events for which the emitter has registered
                 * listeners. The values in the array are strings or `Symbol`s.
                 *
                 * ```js
                 * import { EventEmitter } from 'node:events';
                 *
                 * const myEE = new EventEmitter();
                 * myEE.on('foo', () => {});
                 * myEE.on('bar', () => {});
                 *
                 * const sym = Symbol('symbol');
                 * myEE.on(sym, () => {});
                 *
                 * console.log(myEE.eventNames());
                 * // Prints: [ 'foo', 'bar', Symbol(symbol) ]
                 * ```
                 * @since v6.0.0
                 */
                eventNames(): Array<(string | symbol) & Key2<unknown, T>>;
            }
        }
    }
    export = EventEmitter;
}
declare module "node:events" {
    import events = require("events");
    export = events;
}
=== END FILE ===
=== START FILE: ./node_modules/@types/node/crypto.d.ts ===
/**
 * The `node:crypto` module provides cryptographic functionality that includes a
 * set of wrappers for OpenSSL's hash, HMAC, cipher, decipher, sign, and verify
 * functions.
 *
 * ```js
 * const { createHmac } = await import('node:crypto');
 *
 * const secret = 'abcdefg';
 * const hash = createHmac('sha256', secret)
 *                .update('I love cupcakes')
 *                .digest('hex');
 * console.log(hash);
 * // Prints:
 * //   c0fa1bc00531bd78ef38c628449c5102aeabd49b5dc3a2a516ea6ea959d6658e
 * ```
 * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/crypto.js)
 */
declare module "crypto" {
    import * as stream from "node:stream";
    import { PeerCertificate } from "node:tls";
    /**
     * SPKAC is a Certificate Signing Request mechanism originally implemented by
     * Netscape and was specified formally as part of HTML5's `keygen` element.
     *
     * `<keygen>` is deprecated since [HTML 5.2](https://www.w3.org/TR/html52/changes.html#features-removed) and new projects
     * should not use this element anymore.
     *
     * The `node:crypto` module provides the `Certificate` class for working with SPKAC
     * data. The most common usage is handling output generated by the HTML5 `<keygen>` element. Node.js uses [OpenSSL's SPKAC
     * implementation](https://www.openssl.org/docs/man3.0/man1/openssl-spkac.html) internally.
     * @since v0.11.8
     */
    class Certificate {
        /**
         * ```js
         * const { Certificate } = await import('node:crypto');
         * const spkac = getSpkacSomehow();
         * const challenge = Certificate.exportChallenge(spkac);
         * console.log(challenge.toString('utf8'));
         * // Prints: the challenge as a UTF8 string
         * ```
         * @since v9.0.0
         * @param encoding The `encoding` of the `spkac` string.
         * @return The challenge component of the `spkac` data structure, which includes a public key and a challenge.
         */
        static exportChallenge(spkac: BinaryLike): Buffer;
        /**
         * ```js
         * const { Certificate } = await import('node:crypto');
         * const spkac = getSpkacSomehow();
         * const publicKey = Certificate.exportPublicKey(spkac);
         * console.log(publicKey);
         * // Prints: the public key as <Buffer ...>
         * ```
         * @since v9.0.0
         * @param encoding The `encoding` of the `spkac` string.
         * @return The public key component of the `spkac` data structure, which includes a public key and a challenge.
         */
        static exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
        /**
         * ```js
         * import { Buffer } from 'node:buffer';
         * const { Certificate } = await import('node:crypto');
         *
         * const spkac = getSpkacSomehow();
         * console.log(Certificate.verifySpkac(Buffer.from(spkac)));
         * // Prints: true or false
         * ```
         * @since v9.0.0
         * @param encoding The `encoding` of the `spkac` string.
         * @return `true` if the given `spkac` data structure is valid, `false` otherwise.
         */
        static verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
        /**
         * @deprecated
         * @param spkac
         * @returns The challenge component of the `spkac` data structure,
         * which includes a public key and a challenge.
         */
        exportChallenge(spkac: BinaryLike): Buffer;
        /**
         * @deprecated
         * @param spkac
         * @param encoding The encoding of the spkac string.
         * @returns The public key component of the `spkac` data structure,
         * which includes a public key and a challenge.
         */
        exportPublicKey(spkac: BinaryLike, encoding?: string): Buffer;
        /**
         * @deprecated
         * @param spkac
         * @returns `true` if the given `spkac` data structure is valid,
         * `false` otherwise.
         */
        verifySpkac(spkac: NodeJS.ArrayBufferView): boolean;
    }
    namespace constants {
        // https://nodejs.org/dist/latest-v22.x/docs/api/crypto.html#crypto-constants
        const OPENSSL_VERSION_NUMBER: number;
        /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */
        const SSL_OP_ALL: number;
        /** Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3 */
        const SSL_OP_ALLOW_NO_DHE_KEX: number;
        /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
        const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
        /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
        const SSL_OP_CIPHER_SERVER_PREFERENCE: number;
        /** Instructs OpenSSL to use Cisco's version identifier of DTLS_BAD_VER. */
        const SSL_OP_CISCO_ANYCONNECT: number;
        /** Instructs OpenSSL to turn on cookie exchange. */
        const SSL_OP_COOKIE_EXCHANGE: number;
        /** Instructs OpenSSL to add server-hello extension from an early version of the cryptopro draft. */
        const SSL_OP_CRYPTOPRO_TLSEXT_BUG: number;
        /** Instructs OpenSSL to disable a SSL 3.0/TLS 1.0 vulnerability workaround added in OpenSSL 0.9.6d. */
        const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: number;
        /** Allows initial connection to servers that do not support RI. */
        const SSL_OP_LEGACY_SERVER_CONNECT: number;
        /** Instructs OpenSSL to disable support for SSL/TLS compression. */
        const SSL_OP_NO_COMPRESSION: number;
        /** Instructs OpenSSL to disable encrypt-then-MAC. */
        const SSL_OP_NO_ENCRYPT_THEN_MAC: number;
        const SSL_OP_NO_QUERY_MTU: number;
        /** Instructs OpenSSL to disable renegotiation. */
        const SSL_OP_NO_RENEGOTIATION: number;
        /** Instructs OpenSSL to always start a new session when performing renegotiation. */
        const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
        /** Instructs OpenSSL to turn off SSL v2 */
        const SSL_OP_NO_SSLv2: number;
        /** Instructs OpenSSL to turn off SSL v3 */
        const SSL_OP_NO_SSLv3: number;
        /** Instructs OpenSSL to disable use of RFC4507bis tickets. */
        const SSL_OP_NO_TICKET: number;
        /** Instructs OpenSSL to turn off TLS v1 */
        const SSL_OP_NO_TLSv1: number;
        /** Instructs OpenSSL to turn off TLS v1.1 */
        const SSL_OP_NO_TLSv1_1: number;
        /** Instructs OpenSSL to turn off TLS v1.2 */
        const SSL_OP_NO_TLSv1_2: number;
        /** Instructs OpenSSL to turn off TLS v1.3 */
        const SSL_OP_NO_TLSv1_3: number;
        /** Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if `SSL_OP_CIPHER_SERVER_PREFERENCE` is not enabled. */
        const SSL_OP_PRIORITIZE_CHACHA: number;
        /** Instructs OpenSSL to disable version rollback attack detection. */
        const SSL_OP_TLS_ROLLBACK_BUG: number;
        const ENGINE_METHOD_RSA: number;
        const ENGINE_METHOD_DSA: number;
        const ENGINE_METHOD_DH: number;
        const ENGINE_METHOD_RAND: number;
        const ENGINE_METHOD_EC: number;
        const ENGINE_METHOD_CIPHERS: number;
        const ENGINE_METHOD_DIGESTS: number;
        const ENGINE_METHOD_PKEY_METHS: number;
        const ENGINE_METHOD_PKEY_ASN1_METHS: number;
        const ENGINE_METHOD_ALL: number;
        const ENGINE_METHOD_NONE: number;
        const DH_CHECK_P_NOT_SAFE_PRIME: number;
        const DH_CHECK_P_NOT_PRIME: number;
        const DH_UNABLE_TO_CHECK_GENERATOR: number;
        const DH_NOT_SUITABLE_GENERATOR: number;
        const RSA_PKCS1_PADDING: number;
        const RSA_SSLV23_PADDING: number;
        const RSA_NO_PADDING: number;
        const RSA_PKCS1_OAEP_PADDING: number;
        const RSA_X931_PADDING: number;
        const RSA_PKCS1_PSS_PADDING: number;
        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the digest size when signing or verifying. */
        const RSA_PSS_SALTLEN_DIGEST: number;
        /** Sets the salt length for RSA_PKCS1_PSS_PADDING to the maximum permissible value when signing data. */
        const RSA_PSS_SALTLEN_MAX_SIGN: number;
        /** Causes the salt length for RSA_PKCS1_PSS_PADDING to be determined automatically when verifying a signature. */
        const RSA_PSS_SALTLEN_AUTO: number;
        const POINT_CONVERSION_COMPRESSED: number;
        const POINT_CONVERSION_UNCOMPRESSED: number;
        const POINT_CONVERSION_HYBRID: number;
        /** Specifies the built-in default cipher list used by Node.js (colon-separated values). */
        const defaultCoreCipherList: string;
        /** Specifies the active default cipher list used by the current Node.js process  (colon-separated values). */
        const defaultCipherList: string;
    }
    interface HashOptions extends stream.TransformOptions {
        /**
         * For XOF hash functions such as `shake256`, the
         * outputLength option can be used to specify the desired output length in bytes.
         */
        outputLength?: number | undefined;
    }
    /** @deprecated since v10.0.0 */
    const fips: boolean;
    /**
     * Creates and returns a `Hash` object that can be used to generate hash digests
     * using the given `algorithm`. Optional `options` argument controls stream
     * behavior. For XOF hash functions such as `'shake256'`, the `outputLength` option
     * can be used to specify the desired output length in bytes.
     *
     * The `algorithm` is dependent on the available algorithms supported by the
     * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
     * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
     * display the available digest algorithms.
     *
     * Example: generating the sha256 sum of a file
     *
     * ```js
     * import {
     *   createReadStream,
     * } from 'node:fs';
     * import { argv } from 'node:process';
     * const {
     *   createHash,
     * } = await import('node:crypto');
     *
     * const filename = argv[2];
     *
     * const hash = createHash('sha256');
     *
     * const input = createReadStream(filename);
     * input.on('readable', () => {
     *   // Only one element is going to be produced by the
     *   // hash stream.
     *   const data = input.read();
     *   if (data)
     *     hash.update(data);
     *   else {
     *     console.log(`${hash.digest('hex')} ${filename}`);
     *   }
     * });
     * ```
     * @since v0.1.92
     * @param options `stream.transform` options
     */
    function createHash(algorithm: string, options?: HashOptions): Hash;
    /**
     * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
     * Optional `options` argument controls stream behavior.
     *
     * The `algorithm` is dependent on the available algorithms supported by the
     * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
     * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
     * display the available digest algorithms.
     *
     * The `key` is the HMAC key used to generate the cryptographic HMAC hash. If it is
     * a `KeyObject`, its type must be `secret`. If it is a string, please consider `caveats when using strings as inputs to cryptographic APIs`. If it was
     * obtained from a cryptographically secure source of entropy, such as {@link randomBytes} or {@link generateKey}, its length should not
     * exceed the block size of `algorithm` (e.g., 512 bits for SHA-256).
     *
     * Example: generating the sha256 HMAC of a file
     *
     * ```js
     * import {
     *   createReadStream,
     * } from 'node:fs';
     * import { argv } from 'node:process';
     * const {
     *   createHmac,
     * } = await import('node:crypto');
     *
     * const filename = argv[2];
     *
     * const hmac = createHmac('sha256', 'a secret');
     *
     * const input = createReadStream(filename);
     * input.on('readable', () => {
     *   // Only one element is going to be produced by the
     *   // hash stream.
     *   const data = input.read();
     *   if (data)
     *     hmac.update(data);
     *   else {
     *     console.log(`${hmac.digest('hex')} ${filename}`);
     *   }
     * });
     * ```
     * @since v0.1.94
     * @param options `stream.transform` options
     */
    function createHmac(algorithm: string, key: BinaryLike | KeyObject, options?: stream.TransformOptions): Hmac;
    // https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
    type BinaryToTextEncoding = "base64" | "base64url" | "hex" | "binary";
    type CharacterEncoding = "utf8" | "utf-8" | "utf16le" | "utf-16le" | "latin1";
    type LegacyCharacterEncoding = "ascii" | "binary" | "ucs2" | "ucs-2";
    type Encoding = BinaryToTextEncoding | CharacterEncoding | LegacyCharacterEncoding;
    type ECDHKeyFormat = "compressed" | "uncompressed" | "hybrid";
    /**
     * The `Hash` class is a utility for creating hash digests of data. It can be
     * used in one of two ways:
     *
     * * As a `stream` that is both readable and writable, where data is written
     * to produce a computed hash digest on the readable side, or
     * * Using the `hash.update()` and `hash.digest()` methods to produce the
     * computed hash.
     *
     * The {@link createHash} method is used to create `Hash` instances. `Hash`objects are not to be created directly using the `new` keyword.
     *
     * Example: Using `Hash` objects as streams:
     *
     * ```js
     * const {
     *   createHash,
     * } = await import('node:crypto');
     *
     * const hash = createHash('sha256');
     *
     * hash.on('readable', () => {
     *   // Only one element is going to be produced by the
     *   // hash stream.
     *   const data = hash.read();
     *   if (data) {
     *     console.log(data.toString('hex'));
     *     // Prints:
     *     //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
     *   }
     * });
     *
     * hash.write('some data to hash');
     * hash.end();
     * ```
     *
     * Example: Using `Hash` and piped streams:
     *
     * ```js
     * import { createReadStream } from 'node:fs';
     * import { stdout } from 'node:process';
     * const { createHash } = await import('node:crypto');
     *
     * const hash = createHash('sha256');
     *
     * const input = createReadStream('test.js');
     * input.pipe(hash).setEncoding('hex').pipe(stdout);
     * ```
     *
     * Example: Using the `hash.update()` and `hash.digest()` methods:
     *
     * ```js
     * const {
     *   createHash,
     * } = await import('node:crypto');
     *
     * const hash = createHash('sha256');
     *
     * hash.update('some data to hash');
     * console.log(hash.digest('hex'));
     * // Prints:
     * //   6a2da20943931e9834fc12cfe5bb47bbd9ae43489a30726962b576f4e3993e50
     * ```
     * @since v0.1.92
     */
    class Hash extends stream.Transform {
        private constructor();
        /**
         * Creates a new `Hash` object that contains a deep copy of the internal state
         * of the current `Hash` object.
         *
         * The optional `options` argument controls stream behavior. For XOF hash
         * functions such as `'shake256'`, the `outputLength` option can be used to
         * specify the desired output length in bytes.
         *
         * An error is thrown when an attempt is made to copy the `Hash` object after
         * its `hash.digest()` method has been called.
         *
         * ```js
         * // Calculate a rolling hash.
         * const {
         *   createHash,
         * } = await import('node:crypto');
         *
         * const hash = createHash('sha256');
         *
         * hash.update('one');
         * console.log(hash.copy().digest('hex'));
         *
         * hash.update('two');
         * console.log(hash.copy().digest('hex'));
         *
         * hash.update('three');
         * console.log(hash.copy().digest('hex'));
         *
         * // Etc.
         * ```
         * @since v13.1.0
         * @param options `stream.transform` options
         */
        copy(options?: HashOptions): Hash;
        /**
         * Updates the hash content with the given `data`, the encoding of which
         * is given in `inputEncoding`.
         * If `encoding` is not provided, and the `data` is a string, an
         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
         *
         * This can be called many times with new data as it is streamed.
         * @since v0.1.92
         * @param inputEncoding The `encoding` of the `data` string.
         */
        update(data: BinaryLike): Hash;
        update(data: string, inputEncoding: Encoding): Hash;
        /**
         * Calculates the digest of all of the data passed to be hashed (using the `hash.update()` method).
         * If `encoding` is provided a string will be returned; otherwise
         * a `Buffer` is returned.
         *
         * The `Hash` object can not be used again after `hash.digest()` method has been
         * called. Multiple calls will cause an error to be thrown.
         * @since v0.1.92
         * @param encoding The `encoding` of the return value.
         */
        digest(): Buffer;
        digest(encoding: BinaryToTextEncoding): string;
    }
    /**
     * The `Hmac` class is a utility for creating cryptographic HMAC digests. It can
     * be used in one of two ways:
     *
     * * As a `stream` that is both readable and writable, where data is written
     * to produce a computed HMAC digest on the readable side, or
     * * Using the `hmac.update()` and `hmac.digest()` methods to produce the
     * computed HMAC digest.
     *
     * The {@link createHmac} method is used to create `Hmac` instances. `Hmac`objects are not to be created directly using the `new` keyword.
     *
     * Example: Using `Hmac` objects as streams:
     *
     * ```js
     * const {
     *   createHmac,
     * } = await import('node:crypto');
     *
     * const hmac = createHmac('sha256', 'a secret');
     *
     * hmac.on('readable', () => {
     *   // Only one element is going to be produced by the
     *   // hash stream.
     *   const data = hmac.read();
     *   if (data) {
     *     console.log(data.toString('hex'));
     *     // Prints:
     *     //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
     *   }
     * });
     *
     * hmac.write('some data to hash');
     * hmac.end();
     * ```
     *
     * Example: Using `Hmac` and piped streams:
     *
     * ```js
     * import { createReadStream } from 'node:fs';
     * import { stdout } from 'node:process';
     * const {
     *   createHmac,
     * } = await import('node:crypto');
     *
     * const hmac = createHmac('sha256', 'a secret');
     *
     * const input = createReadStream('test.js');
     * input.pipe(hmac).pipe(stdout);
     * ```
     *
     * Example: Using the `hmac.update()` and `hmac.digest()` methods:
     *
     * ```js
     * const {
     *   createHmac,
     * } = await import('node:crypto');
     *
     * const hmac = createHmac('sha256', 'a secret');
     *
     * hmac.update('some data to hash');
     * console.log(hmac.digest('hex'));
     * // Prints:
     * //   7fd04df92f636fd450bc841c9418e5825c17f33ad9c87c518115a45971f7f77e
     * ```
     * @since v0.1.94
     * @deprecated Since v20.13.0 Calling `Hmac` class directly with `Hmac()` or `new Hmac()` is deprecated due to being internals, not intended for public use. Please use the {@link createHmac} method to create Hmac instances.
     */
    class Hmac extends stream.Transform {
        private constructor();
        /**
         * Updates the `Hmac` content with the given `data`, the encoding of which
         * is given in `inputEncoding`.
         * If `encoding` is not provided, and the `data` is a string, an
         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
         *
         * This can be called many times with new data as it is streamed.
         * @since v0.1.94
         * @param inputEncoding The `encoding` of the `data` string.
         */
        update(data: BinaryLike): Hmac;
        update(data: string, inputEncoding: Encoding): Hmac;
        /**
         * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
         * If `encoding` is
         * provided a string is returned; otherwise a `Buffer` is returned;
         *
         * The `Hmac` object can not be used again after `hmac.digest()` has been
         * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
         * @since v0.1.94
         * @param encoding The `encoding` of the return value.
         */
        digest(): Buffer;
        digest(encoding: BinaryToTextEncoding): string;
    }
    type KeyObjectType = "secret" | "public" | "private";
    interface KeyExportOptions<T extends KeyFormat> {
        type: "pkcs1" | "spki" | "pkcs8" | "sec1";
        format: T;
        cipher?: string | undefined;
        passphrase?: string | Buffer | undefined;
    }
    interface JwkKeyExportOptions {
        format: "jwk";
    }
    interface JsonWebKey {
        crv?: string | undefined;
        d?: string | undefined;
        dp?: string | undefined;
        dq?: string | undefined;
        e?: string | undefined;
        k?: string | undefined;
        kty?: string | undefined;
        n?: string | undefined;
        p?: string | undefined;
        q?: string | undefined;
        qi?: string | undefined;
        x?: string | undefined;
        y?: string | undefined;
        [key: string]: unknown;
    }
    interface AsymmetricKeyDetails {
        /**
         * Key size in bits (RSA, DSA).
         */
        modulusLength?: number | undefined;
        /**
         * Public exponent (RSA).
         */
        publicExponent?: bigint | undefined;
        /**
         * Name of the message digest (RSA-PSS).
         */
        hashAlgorithm?: string | undefined;
        /**
         * Name of the message digest used by MGF1 (RSA-PSS).
         */
        mgf1HashAlgorithm?: string | undefined;
        /**
         * Minimal salt length in bytes (RSA-PSS).
         */
        saltLength?: number | undefined;
        /**
         * Size of q in bits (DSA).
         */
        divisorLength?: number | undefined;
        /**
         * Name of the curve (EC).
         */
        namedCurve?: string | undefined;
    }
    /**
     * Node.js uses a `KeyObject` class to represent a symmetric or asymmetric key,
     * and each kind of key exposes different functions. The {@link createSecretKey}, {@link createPublicKey} and {@link createPrivateKey} methods are used to create `KeyObject`instances. `KeyObject`
     * objects are not to be created directly using the `new`keyword.
     *
     * Most applications should consider using the new `KeyObject` API instead of
     * passing keys as strings or `Buffer`s due to improved security features.
     *
     * `KeyObject` instances can be passed to other threads via `postMessage()`.
     * The receiver obtains a cloned `KeyObject`, and the `KeyObject` does not need to
     * be listed in the `transferList` argument.
     * @since v11.6.0
     */
    class KeyObject {
        private constructor();
        /**
         * Example: Converting a `CryptoKey` instance to a `KeyObject`:
         *
         * ```js
         * const { KeyObject } = await import('node:crypto');
         * const { subtle } = globalThis.crypto;
         *
         * const key = await subtle.generateKey({
         *   name: 'HMAC',
         *   hash: 'SHA-256',
         *   length: 256,
         * }, true, ['sign', 'verify']);
         *
         * const keyObject = KeyObject.from(key);
         * console.log(keyObject.symmetricKeySize);
         * // Prints: 32 (symmetric key size in bytes)
         * ```
         * @since v15.0.0
         */
        static from(key: webcrypto.CryptoKey): KeyObject;
        /**
         * For asymmetric keys, this property represents the type of the key. Supported key
         * types are:
         *
         * * `'rsa'` (OID 1.2.840.113549.1.1.1)
         * * `'rsa-pss'` (OID 1.2.840.113549.1.1.10)
         * * `'dsa'` (OID 1.2.840.10040.4.1)
         * * `'ec'` (OID 1.2.840.10045.2.1)
         * * `'x25519'` (OID 1.3.101.110)
         * * `'x448'` (OID 1.3.101.111)
         * * `'ed25519'` (OID 1.3.101.112)
         * * `'ed448'` (OID 1.3.101.113)
         * * `'dh'` (OID 1.2.840.113549.1.3.1)
         *
         * This property is `undefined` for unrecognized `KeyObject` types and symmetric
         * keys.
         * @since v11.6.0
         */
        asymmetricKeyType?: KeyType | undefined;
        /**
         * This property exists only on asymmetric keys. Depending on the type of the key,
         * this object contains information about the key. None of the information obtained
         * through this property can be used to uniquely identify a key or to compromise
         * the security of the key.
         *
         * For RSA-PSS keys, if the key material contains a `RSASSA-PSS-params` sequence,
         * the `hashAlgorithm`, `mgf1HashAlgorithm`, and `saltLength` properties will be
         * set.
         *
         * Other key details might be exposed via this API using additional attributes.
         * @since v15.7.0
         */
        asymmetricKeyDetails?: AsymmetricKeyDetails | undefined;
        /**
         * For symmetric keys, the following encoding options can be used:
         *
         * For public keys, the following encoding options can be used:
         *
         * For private keys, the following encoding options can be used:
         *
         * The result type depends on the selected encoding format, when PEM the
         * result is a string, when DER it will be a buffer containing the data
         * encoded as DER, when [JWK](https://tools.ietf.org/html/rfc7517) it will be an object.
         *
         * When [JWK](https://tools.ietf.org/html/rfc7517) encoding format was selected, all other encoding options are
         * ignored.
         *
         * PKCS#1, SEC1, and PKCS#8 type keys can be encrypted by using a combination of
         * the `cipher` and `format` options. The PKCS#8 `type` can be used with any`format` to encrypt any key algorithm (RSA, EC, or DH) by specifying a`cipher`. PKCS#1 and SEC1 can only be
         * encrypted by specifying a `cipher`when the PEM `format` is used. For maximum compatibility, use PKCS#8 for
         * encrypted private keys. Since PKCS#8 defines its own
         * encryption mechanism, PEM-level encryption is not supported when encrypting
         * a PKCS#8 key. See [RFC 5208](https://www.rfc-editor.org/rfc/rfc5208.txt) for PKCS#8 encryption and [RFC 1421](https://www.rfc-editor.org/rfc/rfc1421.txt) for
         * PKCS#1 and SEC1 encryption.
         * @since v11.6.0
         */
        export(options: KeyExportOptions<"pem">): string | Buffer;
        export(options?: KeyExportOptions<"der">): Buffer;
        export(options?: JwkKeyExportOptions): JsonWebKey;
        /**
         * Returns `true` or `false` depending on whether the keys have exactly the same
         * type, value, and parameters. This method is not [constant time](https://en.wikipedia.org/wiki/Timing_attack).
         * @since v17.7.0, v16.15.0
         * @param otherKeyObject A `KeyObject` with which to compare `keyObject`.
         */
        equals(otherKeyObject: KeyObject): boolean;
        /**
         * For secret keys, this property represents the size of the key in bytes. This
         * property is `undefined` for asymmetric keys.
         * @since v11.6.0
         */
        symmetricKeySize?: number | undefined;
        /**
         * Converts a `KeyObject` instance to a `CryptoKey`.
         * @since 22.10.0
         */
        toCryptoKey(
            algorithm:
                | webcrypto.AlgorithmIdentifier
                | webcrypto.RsaHashedImportParams
                | webcrypto.EcKeyImportParams
                | webcrypto.HmacImportParams,
            extractable: boolean,
            keyUsages: readonly webcrypto.KeyUsage[],
        ): webcrypto.CryptoKey;
        /**
         * Depending on the type of this `KeyObject`, this property is either`'secret'` for secret (symmetric) keys, `'public'` for public (asymmetric) keys
         * or `'private'` for private (asymmetric) keys.
         * @since v11.6.0
         */
        type: KeyObjectType;
    }
    type CipherCCMTypes = "aes-128-ccm" | "aes-192-ccm" | "aes-256-ccm";
    type CipherGCMTypes = "aes-128-gcm" | "aes-192-gcm" | "aes-256-gcm";
    type CipherOCBTypes = "aes-128-ocb" | "aes-192-ocb" | "aes-256-ocb";
    type CipherChaCha20Poly1305Types = "chacha20-poly1305";
    type BinaryLike = string | NodeJS.ArrayBufferView;
    type CipherKey = BinaryLike | KeyObject;
    interface CipherCCMOptions extends stream.TransformOptions {
        authTagLength: number;
    }
    interface CipherGCMOptions extends stream.TransformOptions {
        authTagLength?: number | undefined;
    }
    interface CipherOCBOptions extends stream.TransformOptions {
        authTagLength: number;
    }
    interface CipherChaCha20Poly1305Options extends stream.TransformOptions {
        /** @default 16 */
        authTagLength?: number | undefined;
    }
    /**
     * Creates and returns a `Cipher` object, with the given `algorithm`, `key` and
     * initialization vector (`iv`).
     *
     * The `options` argument controls stream behavior and is optional except when a
     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the`authTagLength` option is required and specifies the length of the
     * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength`option is not required but can be used to set the length of the authentication
     * tag that will be returned by `getAuthTag()` and defaults to 16 bytes.
     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
     *
     * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
     * recent OpenSSL releases, `openssl list -cipher-algorithms` will
     * display the available cipher algorithms.
     *
     * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
     * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be
     * a `KeyObject` of type `secret`. If the cipher does not need
     * an initialization vector, `iv` may be `null`.
     *
     * When passing strings for `key` or `iv`, please consider `caveats when using strings as inputs to cryptographic APIs`.
     *
     * Initialization vectors should be unpredictable and unique; ideally, they will be
     * cryptographically random. They do not have to be secret: IVs are typically just
     * added to ciphertext messages unencrypted. It may sound contradictory that
     * something has to be unpredictable and unique, but does not have to be secret;
     * remember that an attacker must not be able to predict ahead of time what a
     * given IV will be.
     * @since v0.1.94
     * @param options `stream.transform` options
     */
    function createCipheriv(
        algorithm: CipherCCMTypes,
        key: CipherKey,
        iv: BinaryLike,
        options: CipherCCMOptions,
    ): CipherCCM;
    function createCipheriv(
        algorithm: CipherOCBTypes,
        key: CipherKey,
        iv: BinaryLike,
        options: CipherOCBOptions,
    ): CipherOCB;
    function createCipheriv(
        algorithm: CipherGCMTypes,
        key: CipherKey,
        iv: BinaryLike,
        options?: CipherGCMOptions,
    ): CipherGCM;
    function createCipheriv(
        algorithm: CipherChaCha20Poly1305Types,
        key: CipherKey,
        iv: BinaryLike,
        options?: CipherChaCha20Poly1305Options,
    ): CipherChaCha20Poly1305;
    function createCipheriv(
        algorithm: string,
        key: CipherKey,
        iv: BinaryLike | null,
        options?: stream.TransformOptions,
    ): Cipher;
    /**
     * Instances of the `Cipher` class are used to encrypt data. The class can be
     * used in one of two ways:
     *
     * * As a `stream` that is both readable and writable, where plain unencrypted
     * data is written to produce encrypted data on the readable side, or
     * * Using the `cipher.update()` and `cipher.final()` methods to produce
     * the encrypted data.
     *
     * The {@link createCipheriv} method is
     * used to create `Cipher` instances. `Cipher` objects are not to be created
     * directly using the `new` keyword.
     *
     * Example: Using `Cipher` objects as streams:
     *
     * ```js
     * const {
     *   scrypt,
     *   randomFill,
     *   createCipheriv,
     * } = await import('node:crypto');
     *
     * const algorithm = 'aes-192-cbc';
     * const password = 'Password used to generate key';
     *
     * // First, we'll generate the key. The key length is dependent on the algorithm.
     * // In this case for aes192, it is 24 bytes (192 bits).
     * scrypt(password, 'salt', 24, (err, key) => {
     *   if (err) throw err;
     *   // Then, we'll generate a random initialization vector
     *   randomFill(new Uint8Array(16), (err, iv) => {
     *     if (err) throw err;
     *
     *     // Once we have the key and iv, we can create and use the cipher...
     *     const cipher = createCipheriv(algorithm, key, iv);
     *
     *     let encrypted = '';
     *     cipher.setEncoding('hex');
     *
     *     cipher.on('data', (chunk) => encrypted += chunk);
     *     cipher.on('end', () => console.log(encrypted));
     *
     *     cipher.write('some clear text data');
     *     cipher.end();
     *   });
     * });
     * ```
     *
     * Example: Using `Cipher` and piped streams:
     *
     * ```js
     * import {
     *   createReadStream,
     *   createWriteStream,
     * } from 'node:fs';
     *
     * import {
     *   pipeline,
     * } from 'node:stream';
     *
     * const {
     *   scrypt,
     *   randomFill,
     *   createCipheriv,
     * } = await import('node:crypto');
     *
     * const algorithm = 'aes-192-cbc';
     * const password = 'Password used to generate key';
     *
     * // First, we'll generate the key. The key length is dependent on the algorithm.
     * // In this case for aes192, it is 24 bytes (192 bits).
     * scrypt(password, 'salt', 24, (err, key) => {
     *   if (err) throw err;
     *   // Then, we'll generate a random initialization vector
     *   randomFill(new Uint8Array(16), (err, iv) => {
     *     if (err) throw err;
     *
     *     const cipher = createCipheriv(algorithm, key, iv);
     *
     *     const input = createReadStream('test.js');
     *     const output = createWriteStream('test.enc');
     *
     *     pipeline(input, cipher, output, (err) => {
     *       if (err) throw err;
     *     });
     *   });
     * });
     * ```
     *
     * Example: Using the `cipher.update()` and `cipher.final()` methods:
     *
     * ```js
     * const {
     *   scrypt,
     *   randomFill,
     *   createCipheriv,
     * } = await import('node:crypto');
     *
     * const algorithm = 'aes-192-cbc';
     * const password = 'Password used to generate key';
     *
     * // First, we'll generate the key. The key length is dependent on the algorithm.
     * // In this case for aes192, it is 24 bytes (192 bits).
     * scrypt(password, 'salt', 24, (err, key) => {
     *   if (err) throw err;
     *   // Then, we'll generate a random initialization vector
     *   randomFill(new Uint8Array(16), (err, iv) => {
     *     if (err) throw err;
     *
     *     const cipher = createCipheriv(algorithm, key, iv);
     *
     *     let encrypted = cipher.update('some clear text data', 'utf8', 'hex');
     *     encrypted += cipher.final('hex');
     *     console.log(encrypted);
     *   });
     * });
     * ```
     * @since v0.1.94
     */
    class Cipher extends stream.Transform {
        private constructor();
        /**
         * Updates the cipher with `data`. If the `inputEncoding` argument is given,
         * the `data`argument is a string using the specified encoding. If the `inputEncoding`argument is not given, `data` must be a `Buffer`, `TypedArray`, or `DataView`. If `data` is a `Buffer`,
         * `TypedArray`, or `DataView`, then `inputEncoding` is ignored.
         *
         * The `outputEncoding` specifies the output format of the enciphered
         * data. If the `outputEncoding`is specified, a string using the specified encoding is returned. If no`outputEncoding` is provided, a `Buffer` is returned.
         *
         * The `cipher.update()` method can be called multiple times with new data until `cipher.final()` is called. Calling `cipher.update()` after `cipher.final()` will result in an error being
         * thrown.
         * @since v0.1.94
         * @param inputEncoding The `encoding` of the data.
         * @param outputEncoding The `encoding` of the return value.
         */
        update(data: BinaryLike): Buffer;
        update(data: string, inputEncoding: Encoding): Buffer;
        update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
        update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
        /**
         * Once the `cipher.final()` method has been called, the `Cipher` object can no
         * longer be used to encrypt data. Attempts to call `cipher.final()` more than
         * once will result in an error being thrown.
         * @since v0.1.94
         * @param outputEncoding The `encoding` of the return value.
         * @return Any remaining enciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned.
         */
        final(): Buffer;
        final(outputEncoding: BufferEncoding): string;
        /**
         * When using block encryption algorithms, the `Cipher` class will automatically
         * add padding to the input data to the appropriate block size. To disable the
         * default padding call `cipher.setAutoPadding(false)`.
         *
         * When `autoPadding` is `false`, the length of the entire input data must be a
         * multiple of the cipher's block size or `cipher.final()` will throw an error.
         * Disabling automatic padding is useful for non-standard padding, for instance
         * using `0x0` instead of PKCS padding.
         *
         * The `cipher.setAutoPadding()` method must be called before `cipher.final()`.
         * @since v0.7.1
         * @param [autoPadding=true]
         * @return for method chaining.
         */
        setAutoPadding(autoPadding?: boolean): this;
    }
    interface CipherCCM extends Cipher {
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options: {
                plaintextLength: number;
            },
        ): this;
        getAuthTag(): Buffer;
    }
    interface CipherGCM extends Cipher {
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options?: {
                plaintextLength: number;
            },
        ): this;
        getAuthTag(): Buffer;
    }
    interface CipherOCB extends Cipher {
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options?: {
                plaintextLength: number;
            },
        ): this;
        getAuthTag(): Buffer;
    }
    interface CipherChaCha20Poly1305 extends Cipher {
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options: {
                plaintextLength: number;
            },
        ): this;
        getAuthTag(): Buffer;
    }
    /**
     * Creates and returns a `Decipher` object that uses the given `algorithm`, `key` and initialization vector (`iv`).
     *
     * The `options` argument controls stream behavior and is optional except when a
     * cipher in CCM or OCB mode (e.g. `'aes-128-ccm'`) is used. In that case, the `authTagLength` option is required and specifies the length of the
     * authentication tag in bytes, see `CCM mode`. In GCM mode, the `authTagLength` option is not required but can be used to restrict accepted authentication tags
     * to those with the specified length.
     * For `chacha20-poly1305`, the `authTagLength` option defaults to 16 bytes.
     *
     * The `algorithm` is dependent on OpenSSL, examples are `'aes192'`, etc. On
     * recent OpenSSL releases, `openssl list -cipher-algorithms` will
     * display the available cipher algorithms.
     *
     * The `key` is the raw key used by the `algorithm` and `iv` is an [initialization vector](https://en.wikipedia.org/wiki/Initialization_vector). Both arguments must be `'utf8'` encoded
     * strings,`Buffers`, `TypedArray`, or `DataView`s. The `key` may optionally be
     * a `KeyObject` of type `secret`. If the cipher does not need
     * an initialization vector, `iv` may be `null`.
     *
     * When passing strings for `key` or `iv`, please consider `caveats when using strings as inputs to cryptographic APIs`.
     *
     * Initialization vectors should be unpredictable and unique; ideally, they will be
     * cryptographically random. They do not have to be secret: IVs are typically just
     * added to ciphertext messages unencrypted. It may sound contradictory that
     * something has to be unpredictable and unique, but does not have to be secret;
     * remember that an attacker must not be able to predict ahead of time what a given
     * IV will be.
     * @since v0.1.94
     * @param options `stream.transform` options
     */
    function createDecipheriv(
        algorithm: CipherCCMTypes,
        key: CipherKey,
        iv: BinaryLike,
        options: CipherCCMOptions,
    ): DecipherCCM;
    function createDecipheriv(
        algorithm: CipherOCBTypes,
        key: CipherKey,
        iv: BinaryLike,
        options: CipherOCBOptions,
    ): DecipherOCB;
    function createDecipheriv(
        algorithm: CipherGCMTypes,
        key: CipherKey,
        iv: BinaryLike,
        options?: CipherGCMOptions,
    ): DecipherGCM;
    function createDecipheriv(
        algorithm: CipherChaCha20Poly1305Types,
        key: CipherKey,
        iv: BinaryLike,
        options?: CipherChaCha20Poly1305Options,
    ): DecipherChaCha20Poly1305;
    function createDecipheriv(
        algorithm: string,
        key: CipherKey,
        iv: BinaryLike | null,
        options?: stream.TransformOptions,
    ): Decipher;
    /**
     * Instances of the `Decipher` class are used to decrypt data. The class can be
     * used in one of two ways:
     *
     * * As a `stream` that is both readable and writable, where plain encrypted
     * data is written to produce unencrypted data on the readable side, or
     * * Using the `decipher.update()` and `decipher.final()` methods to
     * produce the unencrypted data.
     *
     * The {@link createDecipheriv} method is
     * used to create `Decipher` instances. `Decipher` objects are not to be created
     * directly using the `new` keyword.
     *
     * Example: Using `Decipher` objects as streams:
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const {
     *   scryptSync,
     *   createDecipheriv,
     * } = await import('node:crypto');
     *
     * const algorithm = 'aes-192-cbc';
     * const password = 'Password used to generate key';
     * // Key length is dependent on the algorithm. In this case for aes192, it is
     * // 24 bytes (192 bits).
     * // Use the async `crypto.scrypt()` instead.
     * const key = scryptSync(password, 'salt', 24);
     * // The IV is usually passed along with the ciphertext.
     * const iv = Buffer.alloc(16, 0); // Initialization vector.
     *
     * const decipher = createDecipheriv(algorithm, key, iv);
     *
     * let decrypted = '';
     * decipher.on('readable', () => {
     *   let chunk;
     *   while (null !== (chunk = decipher.read())) {
     *     decrypted += chunk.toString('utf8');
     *   }
     * });
     * decipher.on('end', () => {
     *   console.log(decrypted);
     *   // Prints: some clear text data
     * });
     *
     * // Encrypted with same algorithm, key and iv.
     * const encrypted =
     *   'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
     * decipher.write(encrypted, 'hex');
     * decipher.end();
     * ```
     *
     * Example: Using `Decipher` and piped streams:
     *
     * ```js
     * import {
     *   createReadStream,
     *   createWriteStream,
     * } from 'node:fs';
     * import { Buffer } from 'node:buffer';
     * const {
     *   scryptSync,
     *   createDecipheriv,
     * } = await import('node:crypto');
     *
     * const algorithm = 'aes-192-cbc';
     * const password = 'Password used to generate key';
     * // Use the async `crypto.scrypt()` instead.
     * const key = scryptSync(password, 'salt', 24);
     * // The IV is usually passed along with the ciphertext.
     * const iv = Buffer.alloc(16, 0); // Initialization vector.
     *
     * const decipher = createDecipheriv(algorithm, key, iv);
     *
     * const input = createReadStream('test.enc');
     * const output = createWriteStream('test.js');
     *
     * input.pipe(decipher).pipe(output);
     * ```
     *
     * Example: Using the `decipher.update()` and `decipher.final()` methods:
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const {
     *   scryptSync,
     *   createDecipheriv,
     * } = await import('node:crypto');
     *
     * const algorithm = 'aes-192-cbc';
     * const password = 'Password used to generate key';
     * // Use the async `crypto.scrypt()` instead.
     * const key = scryptSync(password, 'salt', 24);
     * // The IV is usually passed along with the ciphertext.
     * const iv = Buffer.alloc(16, 0); // Initialization vector.
     *
     * const decipher = createDecipheriv(algorithm, key, iv);
     *
     * // Encrypted using same algorithm, key and iv.
     * const encrypted =
     *   'e5f79c5915c02171eec6b212d5520d44480993d7d622a7c4c2da32f6efda0ffa';
     * let decrypted = decipher.update(encrypted, 'hex', 'utf8');
     * decrypted += decipher.final('utf8');
     * console.log(decrypted);
     * // Prints: some clear text data
     * ```
     * @since v0.1.94
     */
    class Decipher extends stream.Transform {
        private constructor();
        /**
         * Updates the decipher with `data`. If the `inputEncoding` argument is given,
         * the `data` argument is a string using the specified encoding. If the `inputEncoding` argument is not given, `data` must be a `Buffer`. If `data` is a `Buffer` then `inputEncoding` is
         * ignored.
         *
         * The `outputEncoding` specifies the output format of the enciphered
         * data. If the `outputEncoding` is specified, a string using the specified encoding is returned. If no `outputEncoding` is provided, a `Buffer` is returned.
         *
         * The `decipher.update()` method can be called multiple times with new data until `decipher.final()` is called. Calling `decipher.update()` after `decipher.final()` will result in an error
         * being thrown.
         * @since v0.1.94
         * @param inputEncoding The `encoding` of the `data` string.
         * @param outputEncoding The `encoding` of the return value.
         */
        update(data: NodeJS.ArrayBufferView): Buffer;
        update(data: string, inputEncoding: Encoding): Buffer;
        update(data: NodeJS.ArrayBufferView, inputEncoding: undefined, outputEncoding: Encoding): string;
        update(data: string, inputEncoding: Encoding | undefined, outputEncoding: Encoding): string;
        /**
         * Once the `decipher.final()` method has been called, the `Decipher` object can
         * no longer be used to decrypt data. Attempts to call `decipher.final()` more
         * than once will result in an error being thrown.
         * @since v0.1.94
         * @param outputEncoding The `encoding` of the return value.
         * @return Any remaining deciphered contents. If `outputEncoding` is specified, a string is returned. If an `outputEncoding` is not provided, a {@link Buffer} is returned.
         */
        final(): Buffer;
        final(outputEncoding: BufferEncoding): string;
        /**
         * When data has been encrypted without standard block padding, calling `decipher.setAutoPadding(false)` will disable automatic padding to prevent `decipher.final()` from checking for and
         * removing padding.
         *
         * Turning auto padding off will only work if the input data's length is a
         * multiple of the ciphers block size.
         *
         * The `decipher.setAutoPadding()` method must be called before `decipher.final()`.
         * @since v0.7.1
         * @param [autoPadding=true]
         * @return for method chaining.
         */
        setAutoPadding(auto_padding?: boolean): this;
    }
    interface DecipherCCM extends Decipher {
        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options: {
                plaintextLength: number;
            },
        ): this;
    }
    interface DecipherGCM extends Decipher {
        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options?: {
                plaintextLength: number;
            },
        ): this;
    }
    interface DecipherOCB extends Decipher {
        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options?: {
                plaintextLength: number;
            },
        ): this;
    }
    interface DecipherChaCha20Poly1305 extends Decipher {
        setAuthTag(buffer: NodeJS.ArrayBufferView): this;
        setAAD(
            buffer: NodeJS.ArrayBufferView,
            options: {
                plaintextLength: number;
            },
        ): this;
    }
    interface PrivateKeyInput {
        key: string | Buffer;
        format?: KeyFormat | undefined;
        type?: "pkcs1" | "pkcs8" | "sec1" | undefined;
        passphrase?: string | Buffer | undefined;
        encoding?: string | undefined;
    }
    interface PublicKeyInput {
        key: string | Buffer;
        format?: KeyFormat | undefined;
        type?: "pkcs1" | "spki" | undefined;
        encoding?: string | undefined;
    }
    /**
     * Asynchronously generates a new random secret key of the given `length`. The `type` will determine which validations will be performed on the `length`.
     *
     * ```js
     * const {
     *   generateKey,
     * } = await import('node:crypto');
     *
     * generateKey('hmac', { length: 512 }, (err, key) => {
     *   if (err) throw err;
     *   console.log(key.export().toString('hex'));  // 46e..........620
     * });
     * ```
     *
     * The size of a generated HMAC key should not exceed the block size of the
     * underlying hash function. See {@link createHmac} for more information.
     * @since v15.0.0
     * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
     */
    function generateKey(
        type: "hmac" | "aes",
        options: {
            length: number;
        },
        callback: (err: Error | null, key: KeyObject) => void,
    ): void;
    /**
     * Synchronously generates a new random secret key of the given `length`. The `type` will determine which validations will be performed on the `length`.
     *
     * ```js
     * const {
     *   generateKeySync,
     * } = await import('node:crypto');
     *
     * const key = generateKeySync('hmac', { length: 512 });
     * console.log(key.export().toString('hex'));  // e89..........41e
     * ```
     *
     * The size of a generated HMAC key should not exceed the block size of the
     * underlying hash function. See {@link createHmac} for more information.
     * @since v15.0.0
     * @param type The intended use of the generated secret key. Currently accepted values are `'hmac'` and `'aes'`.
     */
    function generateKeySync(
        type: "hmac" | "aes",
        options: {
            length: number;
        },
    ): KeyObject;
    interface JsonWebKeyInput {
        key: JsonWebKey;
        format: "jwk";
    }
    /**
     * Creates and returns a new key object containing a private key. If `key` is a
     * string or `Buffer`, `format` is assumed to be `'pem'`; otherwise, `key` must be an object with the properties described above.
     *
     * If the private key is encrypted, a `passphrase` must be specified. The length
     * of the passphrase is limited to 1024 bytes.
     * @since v11.6.0
     */
    function createPrivateKey(key: PrivateKeyInput | string | Buffer | JsonWebKeyInput): KeyObject;
    /**
     * Creates and returns a new key object containing a public key. If `key` is a
     * string or `Buffer`, `format` is assumed to be `'pem'`; if `key` is a `KeyObject` with type `'private'`, the public key is derived from the given private key;
     * otherwise, `key` must be an object with the properties described above.
     *
     * If the format is `'pem'`, the `'key'` may also be an X.509 certificate.
     *
     * Because public keys can be derived from private keys, a private key may be
     * passed instead of a public key. In that case, this function behaves as if {@link createPrivateKey} had been called, except that the type of the
     * returned `KeyObject` will be `'public'` and that the private key cannot be
     * extracted from the returned `KeyObject`. Similarly, if a `KeyObject` with type `'private'` is given, a new `KeyObject` with type `'public'` will be returned
     * and it will be impossible to extract the private key from the returned object.
     * @since v11.6.0
     */
    function createPublicKey(key: PublicKeyInput | string | Buffer | KeyObject | JsonWebKeyInput): KeyObject;
    /**
     * Creates and returns a new key object containing a secret key for symmetric
     * encryption or `Hmac`.
     * @since v11.6.0
     * @param encoding The string encoding when `key` is a string.
     */
    function createSecretKey(key: NodeJS.ArrayBufferView): KeyObject;
    function createSecretKey(key: string, encoding: BufferEncoding): KeyObject;
    /**
     * Creates and returns a `Sign` object that uses the given `algorithm`. Use {@link getHashes} to obtain the names of the available digest algorithms.
     * Optional `options` argument controls the `stream.Writable` behavior.
     *
     * In some cases, a `Sign` instance can be created using the name of a signature
     * algorithm, such as `'RSA-SHA256'`, instead of a digest algorithm. This will use
     * the corresponding digest algorithm. This does not work for all signature
     * algorithms, such as `'ecdsa-with-SHA256'`, so it is best to always use digest
     * algorithm names.
     * @since v0.1.92
     * @param options `stream.Writable` options
     */
    function createSign(algorithm: string, options?: stream.WritableOptions): Sign;
    type DSAEncoding = "der" | "ieee-p1363";
    interface SigningOptions {
        /**
         * @see crypto.constants.RSA_PKCS1_PADDING
         */
        padding?: number | undefined;
        saltLength?: number | undefined;
        dsaEncoding?: DSAEncoding | undefined;
    }
    interface SignPrivateKeyInput extends PrivateKeyInput, SigningOptions {}
    interface SignKeyObjectInput extends SigningOptions {
        key: KeyObject;
    }
    interface SignJsonWebKeyInput extends JsonWebKeyInput, SigningOptions {}
    interface VerifyPublicKeyInput extends PublicKeyInput, SigningOptions {}
    interface VerifyKeyObjectInput extends SigningOptions {
        key: KeyObject;
    }
    interface VerifyJsonWebKeyInput extends JsonWebKeyInput, SigningOptions {}
    type KeyLike = string | Buffer | KeyObject;
    /**
     * The `Sign` class is a utility for generating signatures. It can be used in one
     * of two ways:
     *
     * * As a writable `stream`, where data to be signed is written and the `sign.sign()` method is used to generate and return the signature, or
     * * Using the `sign.update()` and `sign.sign()` methods to produce the
     * signature.
     *
     * The {@link createSign} method is used to create `Sign` instances. The
     * argument is the string name of the hash function to use. `Sign` objects are not
     * to be created directly using the `new` keyword.
     *
     * Example: Using `Sign` and `Verify` objects as streams:
     *
     * ```js
     * const {
     *   generateKeyPairSync,
     *   createSign,
     *   createVerify,
     * } = await import('node:crypto');
     *
     * const { privateKey, publicKey } = generateKeyPairSync('ec', {
     *   namedCurve: 'sect239k1',
     * });
     *
     * const sign = createSign('SHA256');
     * sign.write('some data to sign');
     * sign.end();
     * const signature = sign.sign(privateKey, 'hex');
     *
     * const verify = createVerify('SHA256');
     * verify.write('some data to sign');
     * verify.end();
     * console.log(verify.verify(publicKey, signature, 'hex'));
     * // Prints: true
     * ```
     *
     * Example: Using the `sign.update()` and `verify.update()` methods:
     *
     * ```js
     * const {
     *   generateKeyPairSync,
     *   createSign,
     *   createVerify,
     * } = await import('node:crypto');
     *
     * const { privateKey, publicKey } = generateKeyPairSync('rsa', {
     *   modulusLength: 2048,
     * });
     *
     * const sign = createSign('SHA256');
     * sign.update('some data to sign');
     * sign.end();
     * const signature = sign.sign(privateKey);
     *
     * const verify = createVerify('SHA256');
     * verify.update('some data to sign');
     * verify.end();
     * console.log(verify.verify(publicKey, signature));
     * // Prints: true
     * ```
     * @since v0.1.92
     */
    class Sign extends stream.Writable {
        private constructor();
        /**
         * Updates the `Sign` content with the given `data`, the encoding of which
         * is given in `inputEncoding`.
         * If `encoding` is not provided, and the `data` is a string, an
         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
         *
         * This can be called many times with new data as it is streamed.
         * @since v0.1.92
         * @param inputEncoding The `encoding` of the `data` string.
         */
        update(data: BinaryLike): this;
        update(data: string, inputEncoding: Encoding): this;
        /**
         * Calculates the signature on all the data passed through using either `sign.update()` or `sign.write()`.
         *
         * If `privateKey` is not a `KeyObject`, this function behaves as if `privateKey` had been passed to {@link createPrivateKey}. If it is an
         * object, the following additional properties can be passed:
         *
         * If `outputEncoding` is provided a string is returned; otherwise a `Buffer` is returned.
         *
         * The `Sign` object can not be again used after `sign.sign()` method has been
         * called. Multiple calls to `sign.sign()` will result in an error being thrown.
         * @since v0.1.92
         */
        sign(privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput): Buffer;
        sign(
            privateKey: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput,
            outputFormat: BinaryToTextEncoding,
        ): string;
    }
    /**
     * Creates and returns a `Verify` object that uses the given algorithm.
     * Use {@link getHashes} to obtain an array of names of the available
     * signing algorithms. Optional `options` argument controls the `stream.Writable` behavior.
     *
     * In some cases, a `Verify` instance can be created using the name of a signature
     * algorithm, such as `'RSA-SHA256'`, instead of a digest algorithm. This will use
     * the corresponding digest algorithm. This does not work for all signature
     * algorithms, such as `'ecdsa-with-SHA256'`, so it is best to always use digest
     * algorithm names.
     * @since v0.1.92
     * @param options `stream.Writable` options
     */
    function createVerify(algorithm: string, options?: stream.WritableOptions): Verify;
    /**
     * The `Verify` class is a utility for verifying signatures. It can be used in one
     * of two ways:
     *
     * * As a writable `stream` where written data is used to validate against the
     * supplied signature, or
     * * Using the `verify.update()` and `verify.verify()` methods to verify
     * the signature.
     *
     * The {@link createVerify} method is used to create `Verify` instances. `Verify` objects are not to be created directly using the `new` keyword.
     *
     * See `Sign` for examples.
     * @since v0.1.92
     */
    class Verify extends stream.Writable {
        private constructor();
        /**
         * Updates the `Verify` content with the given `data`, the encoding of which
         * is given in `inputEncoding`.
         * If `inputEncoding` is not provided, and the `data` is a string, an
         * encoding of `'utf8'` is enforced. If `data` is a `Buffer`, `TypedArray`, or `DataView`, then `inputEncoding` is ignored.
         *
         * This can be called many times with new data as it is streamed.
         * @since v0.1.92
         * @param inputEncoding The `encoding` of the `data` string.
         */
        update(data: BinaryLike): Verify;
        update(data: string, inputEncoding: Encoding): Verify;
        /**
         * Verifies the provided data using the given `object` and `signature`.
         *
         * If `object` is not a `KeyObject`, this function behaves as if `object` had been passed to {@link createPublicKey}. If it is an
         * object, the following additional properties can be passed:
         *
         * The `signature` argument is the previously calculated signature for the data, in
         * the `signatureEncoding`.
         * If a `signatureEncoding` is specified, the `signature` is expected to be a
         * string; otherwise `signature` is expected to be a `Buffer`, `TypedArray`, or `DataView`.
         *
         * The `verify` object can not be used again after `verify.verify()` has been
         * called. Multiple calls to `verify.verify()` will result in an error being
         * thrown.
         *
         * Because public keys can be derived from private keys, a private key may
         * be passed instead of a public key.
         * @since v0.1.92
         */
        verify(
            object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput,
            signature: NodeJS.ArrayBufferView,
        ): boolean;
        verify(
            object: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput,
            signature: string,
            signature_format?: BinaryToTextEncoding,
        ): boolean;
    }
    /**
     * Creates a `DiffieHellman` key exchange object using the supplied `prime` and an
     * optional specific `generator`.
     *
     * The `generator` argument can be a number, string, or `Buffer`. If `generator` is not specified, the value `2` is used.
     *
     * If `primeEncoding` is specified, `prime` is expected to be a string; otherwise
     * a `Buffer`, `TypedArray`, or `DataView` is expected.
     *
     * If `generatorEncoding` is specified, `generator` is expected to be a string;
     * otherwise a number, `Buffer`, `TypedArray`, or `DataView` is expected.
     * @since v0.11.12
     * @param primeEncoding The `encoding` of the `prime` string.
     * @param [generator=2]
     * @param generatorEncoding The `encoding` of the `generator` string.
     */
    function createDiffieHellman(primeLength: number, generator?: number): DiffieHellman;
    function createDiffieHellman(
        prime: ArrayBuffer | NodeJS.ArrayBufferView,
        generator?: number | ArrayBuffer | NodeJS.ArrayBufferView,
    ): DiffieHellman;
    function createDiffieHellman(
        prime: ArrayBuffer | NodeJS.ArrayBufferView,
        generator: string,
        generatorEncoding: BinaryToTextEncoding,
    ): DiffieHellman;
    function createDiffieHellman(
        prime: string,
        primeEncoding: BinaryToTextEncoding,
        generator?: number | ArrayBuffer | NodeJS.ArrayBufferView,
    ): DiffieHellman;
    function createDiffieHellman(
        prime: string,
        primeEncoding: BinaryToTextEncoding,
        generator: string,
        generatorEncoding: BinaryToTextEncoding,
    ): DiffieHellman;
    /**
     * The `DiffieHellman` class is a utility for creating Diffie-Hellman key
     * exchanges.
     *
     * Instances of the `DiffieHellman` class can be created using the {@link createDiffieHellman} function.
     *
     * ```js
     * import assert from 'node:assert';
     *
     * const {
     *   createDiffieHellman,
     * } = await import('node:crypto');
     *
     * // Generate Alice's keys...
     * const alice = createDiffieHellman(2048);
     * const aliceKey = alice.generateKeys();
     *
     * // Generate Bob's keys...
     * const bob = createDiffieHellman(alice.getPrime(), alice.getGenerator());
     * const bobKey = bob.generateKeys();
     *
     * // Exchange and generate the secret...
     * const aliceSecret = alice.computeSecret(bobKey);
     * const bobSecret = bob.computeSecret(aliceKey);
     *
     * // OK
     * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
     * ```
     * @since v0.5.0
     */
    class DiffieHellman {
        private constructor();
        /**
         * Generates private and public Diffie-Hellman key values unless they have been
         * generated or computed already, and returns
         * the public key in the specified `encoding`. This key should be
         * transferred to the other party.
         * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned.
         *
         * This function is a thin wrapper around [`DH_generate_key()`](https://www.openssl.org/docs/man3.0/man3/DH_generate_key.html). In particular,
         * once a private key has been generated or set, calling this function only updates
         * the public key but does not generate a new private key.
         * @since v0.5.0
         * @param encoding The `encoding` of the return value.
         */
        generateKeys(): Buffer;
        generateKeys(encoding: BinaryToTextEncoding): string;
        /**
         * Computes the shared secret using `otherPublicKey` as the other
         * party's public key and returns the computed shared secret. The supplied
         * key is interpreted using the specified `inputEncoding`, and secret is
         * encoded using specified `outputEncoding`.
         * If the `inputEncoding` is not
         * provided, `otherPublicKey` is expected to be a `Buffer`, `TypedArray`, or `DataView`.
         *
         * If `outputEncoding` is given a string is returned; otherwise, a `Buffer` is returned.
         * @since v0.5.0
         * @param inputEncoding The `encoding` of an `otherPublicKey` string.
         * @param outputEncoding The `encoding` of the return value.
         */
        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, inputEncoding?: null, outputEncoding?: null): Buffer;
        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding, outputEncoding?: null): Buffer;
        computeSecret(
            otherPublicKey: NodeJS.ArrayBufferView,
            inputEncoding: null,
            outputEncoding: BinaryToTextEncoding,
        ): string;
        computeSecret(
            otherPublicKey: string,
            inputEncoding: BinaryToTextEncoding,
            outputEncoding: BinaryToTextEncoding,
        ): string;
        /**
         * Returns the Diffie-Hellman prime in the specified `encoding`.
         * If `encoding` is provided a string is
         * returned; otherwise a `Buffer` is returned.
         * @since v0.5.0
         * @param encoding The `encoding` of the return value.
         */
        getPrime(): Buffer;
        getPrime(encoding: BinaryToTextEncoding): string;
        /**
         * Returns the Diffie-Hellman generator in the specified `encoding`.
         * If `encoding` is provided a string is
         * returned; otherwise a `Buffer` is returned.
         * @since v0.5.0
         * @param encoding The `encoding` of the return value.
         */
        getGenerator(): Buffer;
        getGenerator(encoding: BinaryToTextEncoding): string;
        /**
         * Returns the Diffie-Hellman public key in the specified `encoding`.
         * If `encoding` is provided a
         * string is returned; otherwise a `Buffer` is returned.
         * @since v0.5.0
         * @param encoding The `encoding` of the return value.
         */
        getPublicKey(): Buffer;
        getPublicKey(encoding: BinaryToTextEncoding): string;
        /**
         * Returns the Diffie-Hellman private key in the specified `encoding`.
         * If `encoding` is provided a
         * string is returned; otherwise a `Buffer` is returned.
         * @since v0.5.0
         * @param encoding The `encoding` of the return value.
         */
        getPrivateKey(): Buffer;
        getPrivateKey(encoding: BinaryToTextEncoding): string;
        /**
         * Sets the Diffie-Hellman public key. If the `encoding` argument is provided, `publicKey` is expected
         * to be a string. If no `encoding` is provided, `publicKey` is expected
         * to be a `Buffer`, `TypedArray`, or `DataView`.
         * @since v0.5.0
         * @param encoding The `encoding` of the `publicKey` string.
         */
        setPublicKey(publicKey: NodeJS.ArrayBufferView): void;
        setPublicKey(publicKey: string, encoding: BufferEncoding): void;
        /**
         * Sets the Diffie-Hellman private key. If the `encoding` argument is provided,`privateKey` is expected
         * to be a string. If no `encoding` is provided, `privateKey` is expected
         * to be a `Buffer`, `TypedArray`, or `DataView`.
         *
         * This function does not automatically compute the associated public key. Either `diffieHellman.setPublicKey()` or `diffieHellman.generateKeys()` can be
         * used to manually provide the public key or to automatically derive it.
         * @since v0.5.0
         * @param encoding The `encoding` of the `privateKey` string.
         */
        setPrivateKey(privateKey: NodeJS.ArrayBufferView): void;
        setPrivateKey(privateKey: string, encoding: BufferEncoding): void;
        /**
         * A bit field containing any warnings and/or errors resulting from a check
         * performed during initialization of the `DiffieHellman` object.
         *
         * The following values are valid for this property (as defined in `node:constants` module):
         *
         * * `DH_CHECK_P_NOT_SAFE_PRIME`
         * * `DH_CHECK_P_NOT_PRIME`
         * * `DH_UNABLE_TO_CHECK_GENERATOR`
         * * `DH_NOT_SUITABLE_GENERATOR`
         * @since v0.11.12
         */
        verifyError: number;
    }
    /**
     * The `DiffieHellmanGroup` class takes a well-known modp group as its argument.
     * It works the same as `DiffieHellman`, except that it does not allow changing its keys after creation.
     * In other words, it does not implement `setPublicKey()` or `setPrivateKey()` methods.
     *
     * ```js
     * const { createDiffieHellmanGroup } = await import('node:crypto');
     * const dh = createDiffieHellmanGroup('modp1');
     * ```
     * The name (e.g. `'modp1'`) is taken from [RFC 2412](https://www.rfc-editor.org/rfc/rfc2412.txt) (modp1 and 2) and [RFC 3526](https://www.rfc-editor.org/rfc/rfc3526.txt):
     * ```bash
     * $ perl -ne 'print "$1\n" if /"(modp\d+)"/' src/node_crypto_groups.h
     * modp1  #  768 bits
     * modp2  # 1024 bits
     * modp5  # 1536 bits
     * modp14 # 2048 bits
     * modp15 # etc.
     * modp16
     * modp17
     * modp18
     * ```
     * @since v0.7.5
     */
    const DiffieHellmanGroup: DiffieHellmanGroupConstructor;
    interface DiffieHellmanGroupConstructor {
        new(name: string): DiffieHellmanGroup;
        (name: string): DiffieHellmanGroup;
        readonly prototype: DiffieHellmanGroup;
    }
    type DiffieHellmanGroup = Omit<DiffieHellman, "setPublicKey" | "setPrivateKey">;
    /**
     * Creates a predefined `DiffieHellmanGroup` key exchange object. The
     * supported groups are listed in the documentation for `DiffieHellmanGroup`.
     *
     * The returned object mimics the interface of objects created by {@link createDiffieHellman}, but will not allow changing
     * the keys (with `diffieHellman.setPublicKey()`, for example). The
     * advantage of using this method is that the parties do not have to
     * generate nor exchange a group modulus beforehand, saving both processor
     * and communication time.
     *
     * Example (obtaining a shared secret):
     *
     * ```js
     * const {
     *   getDiffieHellman,
     * } = await import('node:crypto');
     * const alice = getDiffieHellman('modp14');
     * const bob = getDiffieHellman('modp14');
     *
     * alice.generateKeys();
     * bob.generateKeys();
     *
     * const aliceSecret = alice.computeSecret(bob.getPublicKey(), null, 'hex');
     * const bobSecret = bob.computeSecret(alice.getPublicKey(), null, 'hex');
     *
     * // aliceSecret and bobSecret should be the same
     * console.log(aliceSecret === bobSecret);
     * ```
     * @since v0.7.5
     */
    function getDiffieHellman(groupName: string): DiffieHellmanGroup;
    /**
     * An alias for {@link getDiffieHellman}
     * @since v0.9.3
     */
    function createDiffieHellmanGroup(name: string): DiffieHellmanGroup;
    /**
     * Provides an asynchronous Password-Based Key Derivation Function 2 (PBKDF2)
     * implementation. A selected HMAC digest algorithm specified by `digest` is
     * applied to derive a key of the requested byte length (`keylen`) from the `password`, `salt` and `iterations`.
     *
     * The supplied `callback` function is called with two arguments: `err` and `derivedKey`. If an error occurs while deriving the key, `err` will be set;
     * otherwise `err` will be `null`. By default, the successfully generated `derivedKey` will be passed to the callback as a `Buffer`. An error will be
     * thrown if any of the input arguments specify invalid values or types.
     *
     * The `iterations` argument must be a number set as high as possible. The
     * higher the number of iterations, the more secure the derived key will be,
     * but will take a longer amount of time to complete.
     *
     * The `salt` should be as unique as possible. It is recommended that a salt is
     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
     *
     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
     *
     * ```js
     * const {
     *   pbkdf2,
     * } = await import('node:crypto');
     *
     * pbkdf2('secret', 'salt', 100000, 64, 'sha512', (err, derivedKey) => {
     *   if (err) throw err;
     *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
     * });
     * ```
     *
     * An array of supported digest functions can be retrieved using {@link getHashes}.
     *
     * This API uses libuv's threadpool, which can have surprising and
     * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information.
     * @since v0.5.5
     */
    function pbkdf2(
        password: BinaryLike,
        salt: BinaryLike,
        iterations: number,
        keylen: number,
        digest: string,
        callback: (err: Error | null, derivedKey: Buffer) => void,
    ): void;
    /**
     * Provides a synchronous Password-Based Key Derivation Function 2 (PBKDF2)
     * implementation. A selected HMAC digest algorithm specified by `digest` is
     * applied to derive a key of the requested byte length (`keylen`) from the `password`, `salt` and `iterations`.
     *
     * If an error occurs an `Error` will be thrown, otherwise the derived key will be
     * returned as a `Buffer`.
     *
     * The `iterations` argument must be a number set as high as possible. The
     * higher the number of iterations, the more secure the derived key will be,
     * but will take a longer amount of time to complete.
     *
     * The `salt` should be as unique as possible. It is recommended that a salt is
     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
     *
     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
     *
     * ```js
     * const {
     *   pbkdf2Sync,
     * } = await import('node:crypto');
     *
     * const key = pbkdf2Sync('secret', 'salt', 100000, 64, 'sha512');
     * console.log(key.toString('hex'));  // '3745e48...08d59ae'
     * ```
     *
     * An array of supported digest functions can be retrieved using {@link getHashes}.
     * @since v0.9.3
     */
    function pbkdf2Sync(
        password: BinaryLike,
        salt: BinaryLike,
        iterations: number,
        keylen: number,
        digest: string,
    ): Buffer;
    /**
     * Generates cryptographically strong pseudorandom data. The `size` argument
     * is a number indicating the number of bytes to generate.
     *
     * If a `callback` function is provided, the bytes are generated asynchronously
     * and the `callback` function is invoked with two arguments: `err` and `buf`.
     * If an error occurs, `err` will be an `Error` object; otherwise it is `null`. The `buf` argument is a `Buffer` containing the generated bytes.
     *
     * ```js
     * // Asynchronous
     * const {
     *   randomBytes,
     * } = await import('node:crypto');
     *
     * randomBytes(256, (err, buf) => {
     *   if (err) throw err;
     *   console.log(`${buf.length} bytes of random data: ${buf.toString('hex')}`);
     * });
     * ```
     *
     * If the `callback` function is not provided, the random bytes are generated
     * synchronously and returned as a `Buffer`. An error will be thrown if
     * there is a problem generating the bytes.
     *
     * ```js
     * // Synchronous
     * const {
     *   randomBytes,
     * } = await import('node:crypto');
     *
     * const buf = randomBytes(256);
     * console.log(
     *   `${buf.length} bytes of random data: ${buf.toString('hex')}`);
     * ```
     *
     * The `crypto.randomBytes()` method will not complete until there is
     * sufficient entropy available.
     * This should normally never take longer than a few milliseconds. The only time
     * when generating the random bytes may conceivably block for a longer period of
     * time is right after boot, when the whole system is still low on entropy.
     *
     * This API uses libuv's threadpool, which can have surprising and
     * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information.
     *
     * The asynchronous version of `crypto.randomBytes()` is carried out in a single
     * threadpool request. To minimize threadpool task length variation, partition
     * large `randomBytes` requests when doing so as part of fulfilling a client
     * request.
     * @since v0.5.8
     * @param size The number of bytes to generate. The `size` must not be larger than `2**31 - 1`.
     * @return if the `callback` function is not provided.
     */
    function randomBytes(size: number): Buffer;
    function randomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
    function pseudoRandomBytes(size: number): Buffer;
    function pseudoRandomBytes(size: number, callback: (err: Error | null, buf: Buffer) => void): void;
    /**
     * Return a random integer `n` such that `min <= n < max`.  This
     * implementation avoids [modulo bias](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias).
     *
     * The range (`max - min`) must be less than 2**48. `min` and `max` must
     * be [safe integers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
     *
     * If the `callback` function is not provided, the random integer is
     * generated synchronously.
     *
     * ```js
     * // Asynchronous
     * const {
     *   randomInt,
     * } = await import('node:crypto');
     *
     * randomInt(3, (err, n) => {
     *   if (err) throw err;
     *   console.log(`Random number chosen from (0, 1, 2): ${n}`);
     * });
     * ```
     *
     * ```js
     * // Synchronous
     * const {
     *   randomInt,
     * } = await import('node:crypto');
     *
     * const n = randomInt(3);
     * console.log(`Random number chosen from (0, 1, 2): ${n}`);
     * ```
     *
     * ```js
     * // With `min` argument
     * const {
     *   randomInt,
     * } = await import('node:crypto');
     *
     * const n = randomInt(1, 7);
     * console.log(`The dice rolled: ${n}`);
     * ```
     * @since v14.10.0, v12.19.0
     * @param [min=0] Start of random range (inclusive).
     * @param max End of random range (exclusive).
     * @param callback `function(err, n) {}`.
     */
    function randomInt(max: number): number;
    function randomInt(min: number, max: number): number;
    function randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
    function randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
    /**
     * Synchronous version of {@link randomFill}.
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const { randomFillSync } = await import('node:crypto');
     *
     * const buf = Buffer.alloc(10);
     * console.log(randomFillSync(buf).toString('hex'));
     *
     * randomFillSync(buf, 5);
     * console.log(buf.toString('hex'));
     *
     * // The above is equivalent to the following:
     * randomFillSync(buf, 5, 5);
     * console.log(buf.toString('hex'));
     * ```
     *
     * Any `ArrayBuffer`, `TypedArray` or `DataView` instance may be passed as`buffer`.
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const { randomFillSync } = await import('node:crypto');
     *
     * const a = new Uint32Array(10);
     * console.log(Buffer.from(randomFillSync(a).buffer,
     *                         a.byteOffset, a.byteLength).toString('hex'));
     *
     * const b = new DataView(new ArrayBuffer(10));
     * console.log(Buffer.from(randomFillSync(b).buffer,
     *                         b.byteOffset, b.byteLength).toString('hex'));
     *
     * const c = new ArrayBuffer(10);
     * console.log(Buffer.from(randomFillSync(c)).toString('hex'));
     * ```
     * @since v7.10.0, v6.13.0
     * @param buffer Must be supplied. The size of the provided `buffer` must not be larger than `2**31 - 1`.
     * @param [offset=0]
     * @param [size=buffer.length - offset]
     * @return The object passed as `buffer` argument.
     */
    function randomFillSync<T extends NodeJS.ArrayBufferView>(buffer: T, offset?: number, size?: number): T;
    /**
     * This function is similar to {@link randomBytes} but requires the first
     * argument to be a `Buffer` that will be filled. It also
     * requires that a callback is passed in.
     *
     * If the `callback` function is not provided, an error will be thrown.
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const { randomFill } = await import('node:crypto');
     *
     * const buf = Buffer.alloc(10);
     * randomFill(buf, (err, buf) => {
     *   if (err) throw err;
     *   console.log(buf.toString('hex'));
     * });
     *
     * randomFill(buf, 5, (err, buf) => {
     *   if (err) throw err;
     *   console.log(buf.toString('hex'));
     * });
     *
     * // The above is equivalent to the following:
     * randomFill(buf, 5, 5, (err, buf) => {
     *   if (err) throw err;
     *   console.log(buf.toString('hex'));
     * });
     * ```
     *
     * Any `ArrayBuffer`, `TypedArray`, or `DataView` instance may be passed as `buffer`.
     *
     * While this includes instances of `Float32Array` and `Float64Array`, this
     * function should not be used to generate random floating-point numbers. The
     * result may contain `+Infinity`, `-Infinity`, and `NaN`, and even if the array
     * contains finite numbers only, they are not drawn from a uniform random
     * distribution and have no meaningful lower or upper bounds.
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const { randomFill } = await import('node:crypto');
     *
     * const a = new Uint32Array(10);
     * randomFill(a, (err, buf) => {
     *   if (err) throw err;
     *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
     *     .toString('hex'));
     * });
     *
     * const b = new DataView(new ArrayBuffer(10));
     * randomFill(b, (err, buf) => {
     *   if (err) throw err;
     *   console.log(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength)
     *     .toString('hex'));
     * });
     *
     * const c = new ArrayBuffer(10);
     * randomFill(c, (err, buf) => {
     *   if (err) throw err;
     *   console.log(Buffer.from(buf).toString('hex'));
     * });
     * ```
     *
     * This API uses libuv's threadpool, which can have surprising and
     * negative performance implications for some applications; see the `UV_THREADPOOL_SIZE` documentation for more information.
     *
     * The asynchronous version of `crypto.randomFill()` is carried out in a single
     * threadpool request. To minimize threadpool task length variation, partition
     * large `randomFill` requests when doing so as part of fulfilling a client
     * request.
     * @since v7.10.0, v6.13.0
     * @param buffer Must be supplied. The size of the provided `buffer` must not be larger than `2**31 - 1`.
     * @param [offset=0]
     * @param [size=buffer.length - offset]
     * @param callback `function(err, buf) {}`.
     */
    function randomFill<T extends NodeJS.ArrayBufferView>(
        buffer: T,
        callback: (err: Error | null, buf: T) => void,
    ): void;
    function randomFill<T extends NodeJS.ArrayBufferView>(
        buffer: T,
        offset: number,
        callback: (err: Error | null, buf: T) => void,
    ): void;
    function randomFill<T extends NodeJS.ArrayBufferView>(
        buffer: T,
        offset: number,
        size: number,
        callback: (err: Error | null, buf: T) => void,
    ): void;
    interface ScryptOptions {
        cost?: number | undefined;
        blockSize?: number | undefined;
        parallelization?: number | undefined;
        N?: number | undefined;
        r?: number | undefined;
        p?: number | undefined;
        maxmem?: number | undefined;
    }
    /**
     * Provides an asynchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based
     * key derivation function that is designed to be expensive computationally and
     * memory-wise in order to make brute-force attacks unrewarding.
     *
     * The `salt` should be as unique as possible. It is recommended that a salt is
     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
     *
     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
     *
     * The `callback` function is called with two arguments: `err` and `derivedKey`. `err` is an exception object when key derivation fails, otherwise `err` is `null`. `derivedKey` is passed to the
     * callback as a `Buffer`.
     *
     * An exception is thrown when any of the input arguments specify invalid values
     * or types.
     *
     * ```js
     * const {
     *   scrypt,
     * } = await import('node:crypto');
     *
     * // Using the factory defaults.
     * scrypt('password', 'salt', 64, (err, derivedKey) => {
     *   if (err) throw err;
     *   console.log(derivedKey.toString('hex'));  // '3745e48...08d59ae'
     * });
     * // Using a custom N parameter. Must be a power of two.
     * scrypt('password', 'salt', 64, { N: 1024 }, (err, derivedKey) => {
     *   if (err) throw err;
     *   console.log(derivedKey.toString('hex'));  // '3745e48...aa39b34'
     * });
     * ```
     * @since v10.5.0
     */
    function scrypt(
        password: BinaryLike,
        salt: BinaryLike,
        keylen: number,
        callback: (err: Error | null, derivedKey: Buffer) => void,
    ): void;
    function scrypt(
        password: BinaryLike,
        salt: BinaryLike,
        keylen: number,
        options: ScryptOptions,
        callback: (err: Error | null, derivedKey: Buffer) => void,
    ): void;
    /**
     * Provides a synchronous [scrypt](https://en.wikipedia.org/wiki/Scrypt) implementation. Scrypt is a password-based
     * key derivation function that is designed to be expensive computationally and
     * memory-wise in order to make brute-force attacks unrewarding.
     *
     * The `salt` should be as unique as possible. It is recommended that a salt is
     * random and at least 16 bytes long. See [NIST SP 800-132](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf) for details.
     *
     * When passing strings for `password` or `salt`, please consider `caveats when using strings as inputs to cryptographic APIs`.
     *
     * An exception is thrown when key derivation fails, otherwise the derived key is
     * returned as a `Buffer`.
     *
     * An exception is thrown when any of the input arguments specify invalid values
     * or types.
     *
     * ```js
     * const {
     *   scryptSync,
     * } = await import('node:crypto');
     * // Using the factory defaults.
     *
     * const key1 = scryptSync('password', 'salt', 64);
     * console.log(key1.toString('hex'));  // '3745e48...08d59ae'
     * // Using a custom N parameter. Must be a power of two.
     * const key2 = scryptSync('password', 'salt', 64, { N: 1024 });
     * console.log(key2.toString('hex'));  // '3745e48...aa39b34'
     * ```
     * @since v10.5.0
     */
    function scryptSync(password: BinaryLike, salt: BinaryLike, keylen: number, options?: ScryptOptions): Buffer;
    interface RsaPublicKey {
        key: KeyLike;
        padding?: number | undefined;
    }
    interface RsaPrivateKey {
        key: KeyLike;
        passphrase?: string | undefined;
        /**
         * @default 'sha1'
         */
        oaepHash?: string | undefined;
        oaepLabel?: NodeJS.TypedArray | undefined;
        padding?: number | undefined;
    }
    /**
     * Encrypts the content of `buffer` with `key` and returns a new `Buffer` with encrypted content. The returned data can be decrypted using
     * the corresponding private key, for example using {@link privateDecrypt}.
     *
     * If `key` is not a `KeyObject`, this function behaves as if `key` had been passed to {@link createPublicKey}. If it is an
     * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_OAEP_PADDING`.
     *
     * Because RSA public keys can be derived from private keys, a private key may
     * be passed instead of a public key.
     * @since v0.11.14
     */
    function publicEncrypt(
        key: RsaPublicKey | RsaPrivateKey | KeyLike,
        buffer: NodeJS.ArrayBufferView | string,
    ): Buffer;
    /**
     * Decrypts `buffer` with `key`.`buffer` was previously encrypted using
     * the corresponding private key, for example using {@link privateEncrypt}.
     *
     * If `key` is not a `KeyObject`, this function behaves as if `key` had been passed to {@link createPublicKey}. If it is an
     * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_PADDING`.
     *
     * Because RSA public keys can be derived from private keys, a private key may
     * be passed instead of a public key.
     * @since v1.1.0
     */
    function publicDecrypt(
        key: RsaPublicKey | RsaPrivateKey | KeyLike,
        buffer: NodeJS.ArrayBufferView | string,
    ): Buffer;
    /**
     * Decrypts `buffer` with `privateKey`. `buffer` was previously encrypted using
     * the corresponding public key, for example using {@link publicEncrypt}.
     *
     * If `privateKey` is not a `KeyObject`, this function behaves as if `privateKey` had been passed to {@link createPrivateKey}. If it is an
     * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_OAEP_PADDING`.
     * @since v0.11.14
     */
    function privateDecrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): Buffer;
    /**
     * Encrypts `buffer` with `privateKey`. The returned data can be decrypted using
     * the corresponding public key, for example using {@link publicDecrypt}.
     *
     * If `privateKey` is not a `KeyObject`, this function behaves as if `privateKey` had been passed to {@link createPrivateKey}. If it is an
     * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_PADDING`.
     * @since v1.1.0
     */
    function privateEncrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): Buffer;
    /**
     * ```js
     * const {
     *   getCiphers,
     * } = await import('node:crypto');
     *
     * console.log(getCiphers()); // ['aes-128-cbc', 'aes-128-ccm', ...]
     * ```
     * @since v0.9.3
     * @return An array with the names of the supported cipher algorithms.
     */
    function getCiphers(): string[];
    /**
     * ```js
     * const {
     *   getCurves,
     * } = await import('node:crypto');
     *
     * console.log(getCurves()); // ['Oakley-EC2N-3', 'Oakley-EC2N-4', ...]
     * ```
     * @since v2.3.0
     * @return An array with the names of the supported elliptic curves.
     */
    function getCurves(): string[];
    /**
     * @since v10.0.0
     * @return `1` if and only if a FIPS compliant crypto provider is currently in use, `0` otherwise. A future semver-major release may change the return type of this API to a {boolean}.
     */
    function getFips(): 1 | 0;
    /**
     * Enables the FIPS compliant crypto provider in a FIPS-enabled Node.js build.
     * Throws an error if FIPS mode is not available.
     * @since v10.0.0
     * @param bool `true` to enable FIPS mode.
     */
    function setFips(bool: boolean): void;
    /**
     * ```js
     * const {
     *   getHashes,
     * } = await import('node:crypto');
     *
     * console.log(getHashes()); // ['DSA', 'DSA-SHA', 'DSA-SHA1', ...]
     * ```
     * @since v0.9.3
     * @return An array of the names of the supported hash algorithms, such as `'RSA-SHA256'`. Hash algorithms are also called "digest" algorithms.
     */
    function getHashes(): string[];
    /**
     * The `ECDH` class is a utility for creating Elliptic Curve Diffie-Hellman (ECDH)
     * key exchanges.
     *
     * Instances of the `ECDH` class can be created using the {@link createECDH} function.
     *
     * ```js
     * import assert from 'node:assert';
     *
     * const {
     *   createECDH,
     * } = await import('node:crypto');
     *
     * // Generate Alice's keys...
     * const alice = createECDH('secp521r1');
     * const aliceKey = alice.generateKeys();
     *
     * // Generate Bob's keys...
     * const bob = createECDH('secp521r1');
     * const bobKey = bob.generateKeys();
     *
     * // Exchange and generate the secret...
     * const aliceSecret = alice.computeSecret(bobKey);
     * const bobSecret = bob.computeSecret(aliceKey);
     *
     * assert.strictEqual(aliceSecret.toString('hex'), bobSecret.toString('hex'));
     * // OK
     * ```
     * @since v0.11.14
     */
    class ECDH {
        private constructor();
        /**
         * Converts the EC Diffie-Hellman public key specified by `key` and `curve` to the
         * format specified by `format`. The `format` argument specifies point encoding
         * and can be `'compressed'`, `'uncompressed'` or `'hybrid'`. The supplied key is
         * interpreted using the specified `inputEncoding`, and the returned key is encoded
         * using the specified `outputEncoding`.
         *
         * Use {@link getCurves} to obtain a list of available curve names.
         * On recent OpenSSL releases, `openssl ecparam -list_curves` will also display
         * the name and description of each available elliptic curve.
         *
         * If `format` is not specified the point will be returned in `'uncompressed'` format.
         *
         * If the `inputEncoding` is not provided, `key` is expected to be a `Buffer`, `TypedArray`, or `DataView`.
         *
         * Example (uncompressing a key):
         *
         * ```js
         * const {
         *   createECDH,
         *   ECDH,
         * } = await import('node:crypto');
         *
         * const ecdh = createECDH('secp256k1');
         * ecdh.generateKeys();
         *
         * const compressedKey = ecdh.getPublicKey('hex', 'compressed');
         *
         * const uncompressedKey = ECDH.convertKey(compressedKey,
         *                                         'secp256k1',
         *                                         'hex',
         *                                         'hex',
         *                                         'uncompressed');
         *
         * // The converted key and the uncompressed public key should be the same
         * console.log(uncompressedKey === ecdh.getPublicKey('hex'));
         * ```
         * @since v10.0.0
         * @param inputEncoding The `encoding` of the `key` string.
         * @param outputEncoding The `encoding` of the return value.
         * @param [format='uncompressed']
         */
        static convertKey(
            key: BinaryLike,
            curve: string,
            inputEncoding?: BinaryToTextEncoding,
            outputEncoding?: "latin1" | "hex" | "base64" | "base64url",
            format?: "uncompressed" | "compressed" | "hybrid",
        ): Buffer | string;
        /**
         * Generates private and public EC Diffie-Hellman key values, and returns
         * the public key in the specified `format` and `encoding`. This key should be
         * transferred to the other party.
         *
         * The `format` argument specifies point encoding and can be `'compressed'` or `'uncompressed'`. If `format` is not specified, the point will be returned in`'uncompressed'` format.
         *
         * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned.
         * @since v0.11.14
         * @param encoding The `encoding` of the return value.
         * @param [format='uncompressed']
         */
        generateKeys(): Buffer;
        generateKeys(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
        /**
         * Computes the shared secret using `otherPublicKey` as the other
         * party's public key and returns the computed shared secret. The supplied
         * key is interpreted using specified `inputEncoding`, and the returned secret
         * is encoded using the specified `outputEncoding`.
         * If the `inputEncoding` is not
         * provided, `otherPublicKey` is expected to be a `Buffer`, `TypedArray`, or `DataView`.
         *
         * If `outputEncoding` is given a string will be returned; otherwise a `Buffer` is returned.
         *
         * `ecdh.computeSecret` will throw an`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY` error when `otherPublicKey` lies outside of the elliptic curve. Since `otherPublicKey` is
         * usually supplied from a remote user over an insecure network,
         * be sure to handle this exception accordingly.
         * @since v0.11.14
         * @param inputEncoding The `encoding` of the `otherPublicKey` string.
         * @param outputEncoding The `encoding` of the return value.
         */
        computeSecret(otherPublicKey: NodeJS.ArrayBufferView): Buffer;
        computeSecret(otherPublicKey: string, inputEncoding: BinaryToTextEncoding): Buffer;
        computeSecret(otherPublicKey: NodeJS.ArrayBufferView, outputEncoding: BinaryToTextEncoding): string;
        computeSecret(
            otherPublicKey: string,
            inputEncoding: BinaryToTextEncoding,
            outputEncoding: BinaryToTextEncoding,
        ): string;
        /**
         * If `encoding` is specified, a string is returned; otherwise a `Buffer` is
         * returned.
         * @since v0.11.14
         * @param encoding The `encoding` of the return value.
         * @return The EC Diffie-Hellman in the specified `encoding`.
         */
        getPrivateKey(): Buffer;
        getPrivateKey(encoding: BinaryToTextEncoding): string;
        /**
         * The `format` argument specifies point encoding and can be `'compressed'` or `'uncompressed'`. If `format` is not specified the point will be returned in`'uncompressed'` format.
         *
         * If `encoding` is specified, a string is returned; otherwise a `Buffer` is
         * returned.
         * @since v0.11.14
         * @param encoding The `encoding` of the return value.
         * @param [format='uncompressed']
         * @return The EC Diffie-Hellman public key in the specified `encoding` and `format`.
         */
        getPublicKey(encoding?: null, format?: ECDHKeyFormat): Buffer;
        getPublicKey(encoding: BinaryToTextEncoding, format?: ECDHKeyFormat): string;
        /**
         * Sets the EC Diffie-Hellman private key.
         * If `encoding` is provided, `privateKey` is expected
         * to be a string; otherwise `privateKey` is expected to be a `Buffer`, `TypedArray`, or `DataView`.
         *
         * If `privateKey` is not valid for the curve specified when the `ECDH` object was
         * created, an error is thrown. Upon setting the private key, the associated
         * public point (key) is also generated and set in the `ECDH` object.
         * @since v0.11.14
         * @param encoding The `encoding` of the `privateKey` string.
         */
        setPrivateKey(privateKey: NodeJS.ArrayBufferView): void;
        setPrivateKey(privateKey: string, encoding: BinaryToTextEncoding): void;
    }
    /**
     * Creates an Elliptic Curve Diffie-Hellman (`ECDH`) key exchange object using a
     * predefined curve specified by the `curveName` string. Use {@link getCurves} to obtain a list of available curve names. On recent
     * OpenSSL releases, `openssl ecparam -list_curves` will also display the name
     * and description of each available elliptic curve.
     * @since v0.11.14
     */
    function createECDH(curveName: string): ECDH;
    /**
     * This function compares the underlying bytes that represent the given `ArrayBuffer`, `TypedArray`, or `DataView` instances using a constant-time
     * algorithm.
     *
     * This function does not leak timing information that
     * would allow an attacker to guess one of the values. This is suitable for
     * comparing HMAC digests or secret values like authentication cookies or [capability urls](https://www.w3.org/TR/capability-urls/).
     *
     * `a` and `b` must both be `Buffer`s, `TypedArray`s, or `DataView`s, and they
     * must have the same byte length. An error is thrown if `a` and `b` have
     * different byte lengths.
     *
     * If at least one of `a` and `b` is a `TypedArray` with more than one byte per
     * entry, such as `Uint16Array`, the result will be computed using the platform
     * byte order.
     *
     * **When both of the inputs are `Float32Array`s or `Float64Array`s, this function might return unexpected results due to IEEE 754**
     * **encoding of floating-point numbers. In particular, neither `x === y` nor `Object.is(x, y)` implies that the byte representations of two floating-point**
     * **numbers `x` and `y` are equal.**
     *
     * Use of `crypto.timingSafeEqual` does not guarantee that the _surrounding_ code
     * is timing-safe. Care should be taken to ensure that the surrounding code does
     * not introduce timing vulnerabilities.
     * @since v6.6.0
     */
    function timingSafeEqual(a: NodeJS.ArrayBufferView, b: NodeJS.ArrayBufferView): boolean;
    type KeyType = "rsa" | "rsa-pss" | "dsa" | "ec" | "ed25519" | "ed448" | "x25519" | "x448";
    type KeyFormat = "pem" | "der" | "jwk";
    interface BasePrivateKeyEncodingOptions<T extends KeyFormat> {
        format: T;
        cipher?: string | undefined;
        passphrase?: string | undefined;
    }
    interface KeyPairKeyObjectResult {
        publicKey: KeyObject;
        privateKey: KeyObject;
    }
    interface ED25519KeyPairKeyObjectOptions {}
    interface ED448KeyPairKeyObjectOptions {}
    interface X25519KeyPairKeyObjectOptions {}
    interface X448KeyPairKeyObjectOptions {}
    interface ECKeyPairKeyObjectOptions {
        /**
         * Name of the curve to use
         */
        namedCurve: string;
        /**
         * Must be `'named'` or `'explicit'`. Default: `'named'`.
         */
        paramEncoding?: "explicit" | "named" | undefined;
    }
    interface RSAKeyPairKeyObjectOptions {
        /**
         * Key size in bits
         */
        modulusLength: number;
        /**
         * Public exponent
         * @default 0x10001
         */
        publicExponent?: number | undefined;
    }
    interface RSAPSSKeyPairKeyObjectOptions {
        /**
         * Key size in bits
         */
        modulusLength: number;
        /**
         * Public exponent
         * @default 0x10001
         */
        publicExponent?: number | undefined;
        /**
         * Name of the message digest
         */
        hashAlgorithm?: string;
        /**
         * Name of the message digest used by MGF1
         */
        mgf1HashAlgorithm?: string;
        /**
         * Minimal salt length in bytes
         */
        saltLength?: string;
    }
    interface DSAKeyPairKeyObjectOptions {
        /**
         * Key size in bits
         */
        modulusLength: number;
        /**
         * Size of q in bits
         */
        divisorLength: number;
    }
    interface RSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        /**
         * Key size in bits
         */
        modulusLength: number;
        /**
         * Public exponent
         * @default 0x10001
         */
        publicExponent?: number | undefined;
        publicKeyEncoding: {
            type: "pkcs1" | "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs1" | "pkcs8";
        };
    }
    interface RSAPSSKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        /**
         * Key size in bits
         */
        modulusLength: number;
        /**
         * Public exponent
         * @default 0x10001
         */
        publicExponent?: number | undefined;
        /**
         * Name of the message digest
         */
        hashAlgorithm?: string;
        /**
         * Name of the message digest used by MGF1
         */
        mgf1HashAlgorithm?: string;
        /**
         * Minimal salt length in bytes
         */
        saltLength?: string;
        publicKeyEncoding: {
            type: "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs8";
        };
    }
    interface DSAKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        /**
         * Key size in bits
         */
        modulusLength: number;
        /**
         * Size of q in bits
         */
        divisorLength: number;
        publicKeyEncoding: {
            type: "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs8";
        };
    }
    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> extends ECKeyPairKeyObjectOptions {
        publicKeyEncoding: {
            type: "pkcs1" | "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "sec1" | "pkcs8";
        };
    }
    interface ED25519KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        publicKeyEncoding: {
            type: "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs8";
        };
    }
    interface ED448KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        publicKeyEncoding: {
            type: "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs8";
        };
    }
    interface X25519KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        publicKeyEncoding: {
            type: "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs8";
        };
    }
    interface X448KeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
        publicKeyEncoding: {
            type: "spki";
            format: PubF;
        };
        privateKeyEncoding: BasePrivateKeyEncodingOptions<PrivF> & {
            type: "pkcs8";
        };
    }
    interface KeyPairSyncResult<T1 extends string | Buffer, T2 extends string | Buffer> {
        publicKey: T1;
        privateKey: T2;
    }
    /**
     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
     *
     * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
     * behaves as if `keyObject.export()` had been called on its result. Otherwise,
     * the respective part of the key is returned as a `KeyObject`.
     *
     * When encoding public keys, it is recommended to use `'spki'`. When encoding
     * private keys, it is recommended to use `'pkcs8'` with a strong passphrase,
     * and to keep the passphrase confidential.
     *
     * ```js
     * const {
     *   generateKeyPairSync,
     * } = await import('node:crypto');
     *
     * const {
     *   publicKey,
     *   privateKey,
     * } = generateKeyPairSync('rsa', {
     *   modulusLength: 4096,
     *   publicKeyEncoding: {
     *     type: 'spki',
     *     format: 'pem',
     *   },
     *   privateKeyEncoding: {
     *     type: 'pkcs8',
     *     format: 'pem',
     *     cipher: 'aes-256-cbc',
     *     passphrase: 'top secret',
     *   },
     * });
     * ```
     *
     * The return value `{ publicKey, privateKey }` represents the generated key pair.
     * When PEM encoding was selected, the respective key will be a string, otherwise
     * it will be a buffer containing the data encoded as DER.
     * @since v10.12.0
     * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`.
     */
    function generateKeyPairSync(
        type: "rsa",
        options: RSAKeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "rsa",
        options: RSAKeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "rsa",
        options: RSAKeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "rsa",
        options: RSAKeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "rsa", options: RSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "rsa-pss", options: RSAPSSKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "dsa",
        options: DSAKeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "dsa",
        options: DSAKeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "dsa",
        options: DSAKeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "dsa",
        options: DSAKeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "dsa", options: DSAKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "ec",
        options: ECKeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "ec",
        options: ECKeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "ec",
        options: ECKeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "ec",
        options: ECKeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "ec", options: ECKeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "ed25519",
        options: ED25519KeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "ed25519",
        options: ED25519KeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "ed25519",
        options: ED25519KeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "ed25519",
        options: ED25519KeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "ed25519", options?: ED25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "ed448",
        options: ED448KeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "ed448",
        options: ED448KeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "ed448",
        options: ED448KeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "ed448",
        options: ED448KeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "ed448", options?: ED448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "x25519",
        options: X25519KeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "x25519",
        options: X25519KeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "x25519",
        options: X25519KeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "x25519",
        options: X25519KeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "x25519", options?: X25519KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    function generateKeyPairSync(
        type: "x448",
        options: X448KeyPairOptions<"pem", "pem">,
    ): KeyPairSyncResult<string, string>;
    function generateKeyPairSync(
        type: "x448",
        options: X448KeyPairOptions<"pem", "der">,
    ): KeyPairSyncResult<string, Buffer>;
    function generateKeyPairSync(
        type: "x448",
        options: X448KeyPairOptions<"der", "pem">,
    ): KeyPairSyncResult<Buffer, string>;
    function generateKeyPairSync(
        type: "x448",
        options: X448KeyPairOptions<"der", "der">,
    ): KeyPairSyncResult<Buffer, Buffer>;
    function generateKeyPairSync(type: "x448", options?: X448KeyPairKeyObjectOptions): KeyPairKeyObjectResult;
    /**
     * Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
     * Ed25519, Ed448, X25519, X448, and DH are currently supported.
     *
     * If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
     * behaves as if `keyObject.export()` had been called on its result. Otherwise,
     * the respective part of the key is returned as a `KeyObject`.
     *
     * It is recommended to encode public keys as `'spki'` and private keys as `'pkcs8'` with encryption for long-term storage:
     *
     * ```js
     * const {
     *   generateKeyPair,
     * } = await import('node:crypto');
     *
     * generateKeyPair('rsa', {
     *   modulusLength: 4096,
     *   publicKeyEncoding: {
     *     type: 'spki',
     *     format: 'pem',
     *   },
     *   privateKeyEncoding: {
     *     type: 'pkcs8',
     *     format: 'pem',
     *     cipher: 'aes-256-cbc',
     *     passphrase: 'top secret',
     *   },
     * }, (err, publicKey, privateKey) => {
     *   // Handle errors and use the generated key pair.
     * });
     * ```
     *
     * On completion, `callback` will be called with `err` set to `undefined` and `publicKey` / `privateKey` representing the generated key pair.
     *
     * If this method is invoked as its `util.promisify()` ed version, it returns
     * a `Promise` for an `Object` with `publicKey` and `privateKey` properties.
     * @since v10.12.0
     * @param type Must be `'rsa'`, `'rsa-pss'`, `'dsa'`, `'ec'`, `'ed25519'`, `'ed448'`, `'x25519'`, `'x448'`, or `'dh'`.
     */
    function generateKeyPair(
        type: "rsa",
        options: RSAKeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "rsa",
        options: RSAKeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "rsa",
        options: RSAKeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "rsa",
        options: RSAKeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "rsa",
        options: RSAKeyPairKeyObjectOptions,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "rsa-pss",
        options: RSAPSSKeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "rsa-pss",
        options: RSAPSSKeyPairKeyObjectOptions,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "dsa",
        options: DSAKeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "dsa",
        options: DSAKeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "dsa",
        options: DSAKeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "dsa",
        options: DSAKeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "dsa",
        options: DSAKeyPairKeyObjectOptions,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "ec",
        options: ECKeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "ec",
        options: ECKeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "ec",
        options: ECKeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "ec",
        options: ECKeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "ec",
        options: ECKeyPairKeyObjectOptions,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "ed25519",
        options: ED25519KeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "ed25519",
        options: ED25519KeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "ed25519",
        options: ED25519KeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "ed25519",
        options: ED25519KeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "ed25519",
        options: ED25519KeyPairKeyObjectOptions | undefined,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "ed448",
        options: ED448KeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "ed448",
        options: ED448KeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "ed448",
        options: ED448KeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "ed448",
        options: ED448KeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "ed448",
        options: ED448KeyPairKeyObjectOptions | undefined,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "x25519",
        options: X25519KeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "x25519",
        options: X25519KeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "x25519",
        options: X25519KeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "x25519",
        options: X25519KeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "x25519",
        options: X25519KeyPairKeyObjectOptions | undefined,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    function generateKeyPair(
        type: "x448",
        options: X448KeyPairOptions<"pem", "pem">,
        callback: (err: Error | null, publicKey: string, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "x448",
        options: X448KeyPairOptions<"pem", "der">,
        callback: (err: Error | null, publicKey: string, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "x448",
        options: X448KeyPairOptions<"der", "pem">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: string) => void,
    ): void;
    function generateKeyPair(
        type: "x448",
        options: X448KeyPairOptions<"der", "der">,
        callback: (err: Error | null, publicKey: Buffer, privateKey: Buffer) => void,
    ): void;
    function generateKeyPair(
        type: "x448",
        options: X448KeyPairKeyObjectOptions | undefined,
        callback: (err: Error | null, publicKey: KeyObject, privateKey: KeyObject) => void,
    ): void;
    namespace generateKeyPair {
        function __promisify__(
            type: "rsa",
            options: RSAKeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "rsa",
            options: RSAKeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "rsa",
            options: RSAKeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "rsa",
            options: RSAKeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(type: "rsa", options: RSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "rsa-pss",
            options: RSAPSSKeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "rsa-pss",
            options: RSAPSSKeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "rsa-pss",
            options: RSAPSSKeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "rsa-pss",
            options: RSAPSSKeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "rsa-pss",
            options: RSAPSSKeyPairKeyObjectOptions,
        ): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "dsa",
            options: DSAKeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "dsa",
            options: DSAKeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "dsa",
            options: DSAKeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "dsa",
            options: DSAKeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(type: "dsa", options: DSAKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "ec",
            options: ECKeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "ec",
            options: ECKeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "ec",
            options: ECKeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "ec",
            options: ECKeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(type: "ec", options: ECKeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "ed25519",
            options: ED25519KeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "ed25519",
            options: ED25519KeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "ed25519",
            options: ED25519KeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "ed25519",
            options: ED25519KeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "ed25519",
            options?: ED25519KeyPairKeyObjectOptions,
        ): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "ed448",
            options: ED448KeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "ed448",
            options: ED448KeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "ed448",
            options: ED448KeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "ed448",
            options: ED448KeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(type: "ed448", options?: ED448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "x25519",
            options: X25519KeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "x25519",
            options: X25519KeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "x25519",
            options: X25519KeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "x25519",
            options: X25519KeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "x25519",
            options?: X25519KeyPairKeyObjectOptions,
        ): Promise<KeyPairKeyObjectResult>;
        function __promisify__(
            type: "x448",
            options: X448KeyPairOptions<"pem", "pem">,
        ): Promise<{
            publicKey: string;
            privateKey: string;
        }>;
        function __promisify__(
            type: "x448",
            options: X448KeyPairOptions<"pem", "der">,
        ): Promise<{
            publicKey: string;
            privateKey: Buffer;
        }>;
        function __promisify__(
            type: "x448",
            options: X448KeyPairOptions<"der", "pem">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: string;
        }>;
        function __promisify__(
            type: "x448",
            options: X448KeyPairOptions<"der", "der">,
        ): Promise<{
            publicKey: Buffer;
            privateKey: Buffer;
        }>;
        function __promisify__(type: "x448", options?: X448KeyPairKeyObjectOptions): Promise<KeyPairKeyObjectResult>;
    }
    /**
     * Calculates and returns the signature for `data` using the given private key and
     * algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is
     * dependent upon the key type (especially Ed25519 and Ed448).
     *
     * If `key` is not a `KeyObject`, this function behaves as if `key` had been
     * passed to {@link createPrivateKey}. If it is an object, the following
     * additional properties can be passed:
     *
     * If the `callback` function is provided this function uses libuv's threadpool.
     * @since v12.0.0
     */
    function sign(
        algorithm: string | null | undefined,
        data: NodeJS.ArrayBufferView,
        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput,
    ): Buffer;
    function sign(
        algorithm: string | null | undefined,
        data: NodeJS.ArrayBufferView,
        key: KeyLike | SignKeyObjectInput | SignPrivateKeyInput | SignJsonWebKeyInput,
        callback: (error: Error | null, data: Buffer) => void,
    ): void;
    /**
     * Verifies the given signature for `data` using the given key and algorithm. If `algorithm` is `null` or `undefined`, then the algorithm is dependent upon the
     * key type (especially Ed25519 and Ed448).
     *
     * If `key` is not a `KeyObject`, this function behaves as if `key` had been
     * passed to {@link createPublicKey}. If it is an object, the following
     * additional properties can be passed:
     *
     * The `signature` argument is the previously calculated signature for the `data`.
     *
     * Because public keys can be derived from private keys, a private key or a public
     * key may be passed for `key`.
     *
     * If the `callback` function is provided this function uses libuv's threadpool.
     * @since v12.0.0
     */
    function verify(
        algorithm: string | null | undefined,
        data: NodeJS.ArrayBufferView,
        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput,
        signature: NodeJS.ArrayBufferView,
    ): boolean;
    function verify(
        algorithm: string | null | undefined,
        data: NodeJS.ArrayBufferView,
        key: KeyLike | VerifyKeyObjectInput | VerifyPublicKeyInput | VerifyJsonWebKeyInput,
        signature: NodeJS.ArrayBufferView,
        callback: (error: Error | null, result: boolean) => void,
    ): void;
    /**
     * Computes the Diffie-Hellman secret based on a `privateKey` and a `publicKey`.
     * Both keys must have the same `asymmetricKeyType`, which must be one of `'dh'` (for Diffie-Hellman), `'ec'` (for ECDH), `'x448'`, or `'x25519'` (for ECDH-ES).
     * @since v13.9.0, v12.17.0
     */
    function diffieHellman(options: { privateKey: KeyObject; publicKey: KeyObject }): Buffer;
    /**
     * A utility for creating one-shot hash digests of data. It can be faster than the object-based `crypto.createHash()` when hashing a smaller amount of data
     * (<= 5MB) that's readily available. If the data can be big or if it is streamed, it's still recommended to use `crypto.createHash()` instead. The `algorithm`
     * is dependent on the available algorithms supported by the version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc. On recent releases
     * of OpenSSL, `openssl list -digest-algorithms` will display the available digest algorithms.
     *
     * Example:
     *
     * ```js
     * import crypto from 'node:crypto';
     * import { Buffer } from 'node:buffer';
     *
     * // Hashing a string and return the result as a hex-encoded string.
     * const string = 'Node.js';
     * // 10b3493287f831e81a438811a1ffba01f8cec4b7
     * console.log(crypto.hash('sha1', string));
     *
     * // Encode a base64-encoded string into a Buffer, hash it and return
     * // the result as a buffer.
     * const base64 = 'Tm9kZS5qcw==';
     * // <Buffer 10 b3 49 32 87 f8 31 e8 1a 43 88 11 a1 ff ba 01 f8 ce c4 b7>
     * console.log(crypto.hash('sha1', Buffer.from(base64, 'base64'), 'buffer'));
     * ```
     * @since v21.7.0, v20.12.0
     * @param data When `data` is a string, it will be encoded as UTF-8 before being hashed. If a different input encoding is desired for a string input, user
     *             could encode the string into a `TypedArray` using either `TextEncoder` or `Buffer.from()` and passing the encoded `TypedArray` into this API instead.
     * @param [outputEncoding='hex'] [Encoding](https://nodejs.org/docs/latest-v22.x/api/buffer.html#buffers-and-character-encodings) used to encode the returned digest.
     */
    function hash(algorithm: string, data: BinaryLike, outputEncoding?: BinaryToTextEncoding): string;
    function hash(algorithm: string, data: BinaryLike, outputEncoding: "buffer"): Buffer;
    function hash(
        algorithm: string,
        data: BinaryLike,
        outputEncoding?: BinaryToTextEncoding | "buffer",
    ): string | Buffer;
    type CipherMode = "cbc" | "ccm" | "cfb" | "ctr" | "ecb" | "gcm" | "ocb" | "ofb" | "stream" | "wrap" | "xts";
    interface CipherInfoOptions {
        /**
         * A test key length.
         */
        keyLength?: number | undefined;
        /**
         * A test IV length.
         */
        ivLength?: number | undefined;
    }
    interface CipherInfo {
        /**
         * The name of the cipher.
         */
        name: string;
        /**
         * The nid of the cipher.
         */
        nid: number;
        /**
         * The block size of the cipher in bytes.
         * This property is omitted when mode is 'stream'.
         */
        blockSize?: number | undefined;
        /**
         * The expected or default initialization vector length in bytes.
         * This property is omitted if the cipher does not use an initialization vector.
         */
        ivLength?: number | undefined;
        /**
         * The expected or default key length in bytes.
         */
        keyLength: number;
        /**
         * The cipher mode.
         */
        mode: CipherMode;
    }
    /**
     * Returns information about a given cipher.
     *
     * Some ciphers accept variable length keys and initialization vectors. By default,
     * the `crypto.getCipherInfo()` method will return the default values for these
     * ciphers. To test if a given key length or iv length is acceptable for given
     * cipher, use the `keyLength` and `ivLength` options. If the given values are
     * unacceptable, `undefined` will be returned.
     * @since v15.0.0
     * @param nameOrNid The name or nid of the cipher to query.
     */
    function getCipherInfo(nameOrNid: string | number, options?: CipherInfoOptions): CipherInfo | undefined;
    /**
     * HKDF is a simple key derivation function defined in RFC 5869\. The given `ikm`, `salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
     *
     * The supplied `callback` function is called with two arguments: `err` and `derivedKey`. If an errors occurs while deriving the key, `err` will be set;
     * otherwise `err` will be `null`. The successfully generated `derivedKey` will
     * be passed to the callback as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer). An error will be thrown if any
     * of the input arguments specify invalid values or types.
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const {
     *   hkdf,
     * } = await import('node:crypto');
     *
     * hkdf('sha512', 'key', 'salt', 'info', 64, (err, derivedKey) => {
     *   if (err) throw err;
     *   console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
     * });
     * ```
     * @since v15.0.0
     * @param digest The digest algorithm to use.
     * @param ikm The input keying material. Must be provided but can be zero-length.
     * @param salt The salt value. Must be provided but can be zero-length.
     * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
     * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512`
     * generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
     */
    function hkdf(
        digest: string,
        irm: BinaryLike | KeyObject,
        salt: BinaryLike,
        info: BinaryLike,
        keylen: number,
        callback: (err: Error | null, derivedKey: ArrayBuffer) => void,
    ): void;
    /**
     * Provides a synchronous HKDF key derivation function as defined in RFC 5869\. The
     * given `ikm`, `salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.
     *
     * The successfully generated `derivedKey` will be returned as an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer).
     *
     * An error will be thrown if any of the input arguments specify invalid values or
     * types, or if the derived key cannot be generated.
     *
     * ```js
     * import { Buffer } from 'node:buffer';
     * const {
     *   hkdfSync,
     * } = await import('node:crypto');
     *
     * const derivedKey = hkdfSync('sha512', 'key', 'salt', 'info', 64);
     * console.log(Buffer.from(derivedKey).toString('hex'));  // '24156e2...5391653'
     * ```
     * @since v15.0.0
     * @param digest The digest algorithm to use.
     * @param ikm The input keying material. Must be provided but can be zero-length.
     * @param salt The salt value. Must be provided but can be zero-length.
     * @param info Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes.
     * @param keylen The length of the key to generate. Must be greater than 0. The maximum allowable value is `255` times the number of bytes produced by the selected digest function (e.g. `sha512`
     * generates 64-byte hashes, making the maximum HKDF output 16320 bytes).
     */
    function hkdfSync(
        digest: string,
        ikm: BinaryLike | KeyObject,
        salt: BinaryLike,
        info: BinaryLike,
        keylen: number,
    ): ArrayBuffer;
    interface SecureHeapUsage {
        /**
         * The total allocated secure heap size as specified using the `--secure-heap=n` command-line flag.
         */
        total: number;
        /**
         * The minimum allocation from the secure heap as specified using the `--secure-heap-min` command-line flag.
         */
        min: number;
        /**
         * The total number of bytes currently allocated from the secure heap.
         */
        used: number;
        /**
         * The calculated ratio of `used` to `total` allocated bytes.
         */
        utilization: number;
    }
    /**
     * @since v15.6.0
     */
    function secureHeapUsed(): SecureHeapUsage;
    interface RandomUUIDOptions {
        /**
         * By default, to improve performance,
         * Node.js will pre-emptively generate and persistently cache enough
         * random data to generate up to 128 random UUIDs. To generate a UUID
         * without using the cache, set `disableEntropyCache` to `true`.
         *
         * @default `false`
         */
        disableEntropyCache?: boolean | undefined;
    }
    type UUID = `${string}-${string}-${string}-${string}-${string}`;
    /**
     * Generates a random [RFC 4122](https://www.rfc-editor.org/rfc/rfc4122.txt) version 4 UUID. The UUID is generated using a
     * cryptographic pseudorandom number generator.
     * @since v15.6.0, v14.17.0
     */
    function randomUUID(options?: RandomUUIDOptions): UUID;
    interface X509CheckOptions {
        /**
         * @default 'always'
         */
        subject?: "always" | "default" | "never";
        /**
         * @default true
         */
        wildcards?: boolean;
        /**
         * @default true
         */
        partialWildcards?: boolean;
        /**
         * @default false
         */
        multiLabelWildcards?: boolean;
        /**
         * @default false
         */
        singleLabelSubdomains?: boolean;
    }
    /**
     * Encapsulates an X509 certificate and provides read-only access to
     * its information.
     *
     * ```js
     * const { X509Certificate } = await import('node:crypto');
     *
     * const x509 = new X509Certificate('{... pem encoded cert ...}');
     *
     * console.log(x509.subject);
     * ```
     * @since v15.6.0
     */
    class X509Certificate {
        /**
         * Will be \`true\` if this is a Certificate Authority (CA) certificate.
         * @since v15.6.0
         */
        readonly ca: boolean;
        /**
         * The SHA-1 fingerprint of this certificate.
         *
         * Because SHA-1 is cryptographically broken and because the security of SHA-1 is
         * significantly worse than that of algorithms that are commonly used to sign
         * certificates, consider using `x509.fingerprint256` instead.
         * @since v15.6.0
         */
        readonly fingerprint: string;
        /**
         * The SHA-256 fingerprint of this certificate.
         * @since v15.6.0
         */
        readonly fingerprint256: string;
        /**
         * The SHA-512 fingerprint of this certificate.
         *
         * Because computing the SHA-256 fingerprint is usually faster and because it is
         * only half the size of the SHA-512 fingerprint, `x509.fingerprint256` may be
         * a better choice. While SHA-512 presumably provides a higher level of security in
         * general, the security of SHA-256 matches that of most algorithms that are
         * commonly used to sign certificates.
         * @since v17.2.0, v16.14.0
         */
        readonly fingerprint512: string;
        /**
         * The complete subject of this certificate.
         * @since v15.6.0
         */
        readonly subject: string;
        /**
         * The subject alternative name specified for this certificate.
         *
         * This is a comma-separated list of subject alternative names. Each entry begins
         * with a string identifying the kind of the subject alternative name followed by
         * a colon and the value associated with the entry.
         *
         * Earlier versions of Node.js incorrectly assumed that it is safe to split this
         * property at the two-character sequence `', '` (see [CVE-2021-44532](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2021-44532)). However,
         * both malicious and legitimate certificates can contain subject alternative names
         * that include this sequence when represented as a string.
         *
         * After the prefix denoting the type of the entry, the remainder of each entry
         * might be enclosed in quotes to indicate that the value is a JSON string literal.
         * For backward compatibility, Node.js only uses JSON string literals within this
         * property when necessary to avoid ambiguity. Third-party code should be prepared
         * to handle both possible entry formats.
         * @since v15.6.0
         */
        readonly subjectAltName: string | undefined;
        /**
         * A textual representation of the certificate's authority information access
         * extension.
         *
         * This is a line feed separated list of access descriptions. Each line begins with
         * the access method and the kind of the access location, followed by a colon and
         * the value associated with the access location.
         *
         * After the prefix denoting the access method and the kind of the access location,
         * the remainder of each line might be enclosed in quotes to indicate that the
         * value is a JSON string literal. For backward compatibility, Node.js only uses
         * JSON string literals within this property when necessary to avoid ambiguity.
         * Third-party code should be prepared to handle both possible entry formats.
         * @since v15.6.0
         */
        readonly infoAccess: string | undefined;
        /**
         * An array detailing the key usages for this certificate.
         * @since v15.6.0
         */
        readonly keyUsage: string[];
        /**
         * The issuer identification included in this certificate.
         * @since v15.6.0
         */
        readonly issuer: string;
        /**
         * The issuer certificate or `undefined` if the issuer certificate is not
         * available.
         * @since v15.9.0
         */
        readonly issuerCertificate?: X509Certificate | undefined;
        /**
         * The public key `KeyObject` for this certificate.
         * @since v15.6.0
         */
        readonly publicKey: KeyObject;
        /**
         * A `Buffer` containing the DER encoding of this certificate.
         * @since v15.6.0
         */
        readonly raw: Buffer;
        /**
         * The serial number of this certificate.
         *
         * Serial numbers are assigned by certificate authorities and do not uniquely
         * identify certificates. Consider using `x509.fingerprint256` as a unique
         * identifier instead.
         * @since v15.6.0
         */
        readonly serialNumber: string;
        /**
         * The date/time from which this certificate is considered valid.
         * @since v15.6.0
         */
        readonly validFrom: string;
        /**
         * The date/time from which this certificate is valid, encapsulated in a `Date` object.
         * @since v22.10.0
         */
        readonly validFromDate: Date;
        /**
         * The date/time until which this certificate is considered valid.
         * @since v15.6.0
         */
        readonly validTo: string;
        /**
         * The date/time until which this certificate is valid, encapsulated in a `Date` object.
         * @since v22.10.0
         */
        readonly validToDate: Date;
        constructor(buffer: BinaryLike);
        /**
         * Checks whether the certificate matches the given email address.
         *
         * If the `'subject'` option is undefined or set to `'default'`, the certificate
         * subject is only considered if the subject alternative name extension either does
         * not exist or does not contain any email addresses.
         *
         * If the `'subject'` option is set to `'always'` and if the subject alternative
         * name extension either does not exist or does not contain a matching email
         * address, the certificate subject is considered.
         *
         * If the `'subject'` option is set to `'never'`, the certificate subject is never
         * considered, even if the certificate contains no subject alternative names.
         * @since v15.6.0
         * @return Returns `email` if the certificate matches, `undefined` if it does not.
         */
        checkEmail(email: string, options?: Pick<X509CheckOptions, "subject">): string | undefined;
        /**
         * Checks whether the certificate matches the given host name.
         *
         * If the certificate matches the given host name, the matching subject name is
         * returned. The returned name might be an exact match (e.g., `foo.example.com`)
         * or it might contain wildcards (e.g., `*.example.com`). Because host name
         * comparisons are case-insensitive, the returned subject name might also differ
         * from the given `name` in capitalization.
         *
         * If the `'subject'` option is undefined or set to `'default'`, the certificate
         * subject is only considered if the subject alternative name extension either does
         * not exist or does not contain any DNS names. This behavior is consistent with [RFC 2818](https://www.rfc-editor.org/rfc/rfc2818.txt) ("HTTP Over TLS").
         *
         * If the `'subject'` option is set to `'always'` and if the subject alternative
         * name extension either does not exist or does not contain a matching DNS name,
         * the certificate subject is considered.
         *
         * If the `'subject'` option is set to `'never'`, the certificate subject is never
         * considered, even if the certificate contains no subject alternative names.
         * @since v15.6.0
         * @return Returns a subject name that matches `name`, or `undefined` if no subject name matches `name`.
         */
        checkHost(name: string, options?: X509CheckOptions): string | undefined;
        /**
         * Checks whether the certificate matches the given IP address (IPv4 or IPv6).
         *
         * Only [RFC 5280](https://www.rfc-editor.org/rfc/rfc5280.txt) `iPAddress` subject alternative names are considered, and they
         * must match the given `ip` address exactly. Other subject alternative names as
         * well as the subject field of the certificate are ignored.
         * @since v15.6.0
         * @return Returns `ip` if the certificate matches, `undefined` if it does not.
         */
        checkIP(ip: string): string | undefined;
        /**
         * Checks whether this certificate was issued by the given `otherCert`.
         * @since v15.6.0
         */
        checkIssued(otherCert: X509Certificate): boolean;
        /**
         * Checks whether the public key for this certificate is consistent with
         * the given private key.
         * @since v15.6.0
         * @param privateKey A private key.
         */
        checkPrivateKey(privateKey: KeyObject): boolean;
        /**
         * There is no standard JSON encoding for X509 certificates. The`toJSON()` method returns a string containing the PEM encoded
         * certificate.
         * @since v15.6.0
         */
        toJSON(): string;
        /**
         * Returns information about this certificate using the legacy `certificate object` encoding.
         * @since v15.6.0
         */
        toLegacyObject(): PeerCertificate;
        /**
         * Returns the PEM-encoded certificate.
         * @since v15.6.0
         */
        toString(): string;
        /**
         * Verifies that this certificate was signed by the given public key.
         * Does not perform any other validation checks on the certificate.
         * @since v15.6.0
         * @param publicKey A public key.
         */
        verify(publicKey: KeyObject): boolean;
    }
    type LargeNumberLike = NodeJS.ArrayBufferView | SharedArrayBuffer | ArrayBuffer | bigint;
    interface GeneratePrimeOptions {
        add?: LargeNumberLike | undefined;
        rem?: LargeNumberLike | undefined;
        /**
         * @default false
         */
        safe?: boolean | undefined;
        bigint?: boolean | undefined;
    }
    interface GeneratePrimeOptionsBigInt extends GeneratePrimeOptions {
        bigint: true;
    }
    interface GeneratePrimeOptionsArrayBuffer extends GeneratePrimeOptions {
        bigint?: false | undefined;