export declare function toArray<T>(iterable: Iterable<T>): T[];
export declare function toSet<T>(iterable: Iterable<T>): Set<T>;
export declare function unique<T>(iterable: Iterable<T>): T[];
export declare function byLongestLength<T>(arrA: T[], arrB: T[]): number;
export declare function group<T>(iterableA: Iterable<T>): (iterableB: Iterable<T>) => [T[], T[]];
export declare function doesNotInclude<T>(arr: T[]): (item: T) => boolean;
export declare function doesInclude<T>(arr: T[]): (item: T) => boolean;
export declare function diffGroup<T>([longest, shortest]: [T[], T[]]): T[];
export declare function interGroup<T>([longest, shortest]: [T[], T[]]): T[];
export declare function flatten<T>(iterable: Iterable<T>): (T extends readonly (infer InnerArr)[] ? InnerArr : T)[];
export declare function sort<T>(compareFn: (a: T, b: T) => number): (arr: T[]) => T[];
export declare function difference<T>(iterable: Iterable<T>): (other: Iterable<T>) => T[];
export declare function intersection<T>(iterableA: Iterable<T>): (iterableB: Iterable<T>) => T[];
export declare function union<T>(iterableA: Iterable<T>): (iterableB: Iterable<T>) => T[];
declare type IterTypes = "array" | "string" | "map" | "set" | "other";
export default function Iter<K, V>(iterable: Iterable<V>, type?: IterTypes): {
    value: string | Iterable<V> | Map<K, V>;
    map: (fn: (item: V, i: number, self: V[]) => V) => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
    filter: (fn: (item: V, i: number, self: V[]) => boolean) => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
    reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
    flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
    slice: (start: number, end?: number) => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
    currentType: IterTypes;
    unit: <T_20>(value: Iterable<T_20>, type: IterTypes) => {
        value: string | Iterable<T_20> | Map<unknown, T_20>;
        map: (fn: (item: T_20, i: number, self: T_20[]) => T_20) => any;
        filter: (fn: (item: T_20, i: number, self: T_20[]) => boolean) => any;
        reduce: (fn: (acc: T_20[], item: T_20, i: number, self: T_20[]) => T_20[], init: T_20[]) => any;
        flatMap: (fn: (item: T_20, i: number, self: T_20[]) => T_20[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T_21>(value: Iterable<T_21>, type: IterTypes) => {
            value: string | Iterable<T_21> | Map<unknown, T_21>;
            map: (fn: (item: T_21, i: number, self: T_21[]) => T_21) => any;
            filter: (fn: (item: T_21, i: number, self: T_21[]) => boolean) => any;
            reduce: (fn: (acc: T_21[], item: T_21, i: number, self: T_21[]) => T_21[], init: T_21[]) => any;
            flatMap: (fn: (item: T_21, i: number, self: T_21[]) => T_21[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_22>(value: Iterable<T_22>, type: IterTypes) => {
                value: string | Iterable<T_22> | Map<unknown, T_22>;
                map: (fn: (item: T_22, i: number, self: T_22[]) => T_22) => any;
                filter: (fn: (item: T_22, i: number, self: T_22[]) => boolean) => any;
                reduce: (fn: (acc: T_22[], item: T_22, i: number, self: T_22[]) => T_22[], init: T_22[]) => any;
                flatMap: (fn: (item: T_22, i: number, self: T_22[]) => T_22[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_23>(value: Iterable<T_23>, type: IterTypes) => {
                    value: string | Iterable<T_23> | Map<unknown, T_23>;
                    map: (fn: (item: T_23, i: number, self: T_23[]) => T_23) => any;
                    filter: (fn: (item: T_23, i: number, self: T_23[]) => boolean) => any;
                    reduce: (fn: (acc: T_23[], item: T_23, i: number, self: T_23[]) => T_23[], init: T_23[]) => any;
                    flatMap: (fn: (item: T_23, i: number, self: T_23[]) => T_23[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_24>(value: Iterable<T_24>, type: IterTypes) => {
                        value: string | Iterable<T_24> | Map<unknown, T_24>;
                        map: (fn: (item: T_24, i: number, self: T_24[]) => T_24) => any;
                        filter: (fn: (item: T_24, i: number, self: T_24[]) => boolean) => any;
                        reduce: (fn: (acc: T_24[], item: T_24, i: number, self: T_24[]) => T_24[], init: T_24[]) => any;
                        flatMap: (fn: (item: T_24, i: number, self: T_24[]) => T_24[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_25>(value: Iterable<T_25>, type: IterTypes) => {
                            value: string | Iterable<T_25> | Map<unknown, T_25>;
                            map: (fn: (item: T_25, i: number, self: T_25[]) => T_25) => any;
                            filter: (fn: (item: T_25, i: number, self: T_25[]) => boolean) => any;
                            reduce: (fn: (acc: T_25[], item: T_25, i: number, self: T_25[]) => T_25[], init: T_25[]) => any;
                            flatMap: (fn: (item: T_25, i: number, self: T_25[]) => T_25[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_26>(value: Iterable<T_26>, type: IterTypes) => {
                                value: string | Iterable<T_26> | Map<unknown, T_26>;
                                map: (fn: (item: T_26, i: number, self: T_26[]) => T_26) => any;
                                filter: (fn: (item: T_26, i: number, self: T_26[]) => boolean) => any;
                                reduce: (fn: (acc: T_26[], item: T_26, i: number, self: T_26[]) => T_26[], init: T_26[]) => any;
                                flatMap: (fn: (item: T_26, i: number, self: T_26[]) => T_26[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_27>(value: Iterable<T_27>, type: IterTypes) => {
                                    value: string | Iterable<T_27> | Map<unknown, T_27>;
                                    map: (fn: (item: T_27, i: number, self: T_27[]) => T_27) => any;
                                    filter: (fn: (item: T_27, i: number, self: T_27[]) => boolean) => any;
                                    reduce: (fn: (acc: T_27[], item: T_27, i: number, self: T_27[]) => T_27[], init: T_27[]) => any;
                                    flatMap: (fn: (item: T_27, i: number, self: T_27[]) => T_27[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_28>(value: Iterable<T_28>, type: IterTypes) => {
                                        value: string | Iterable<T_28> | Map<unknown, T_28>;
                                        map: (fn: (item: T_28, i: number, self: T_28[]) => T_28) => any;
                                        filter: (fn: (item: T_28, i: number, self: T_28[]) => boolean) => any;
                                        reduce: (fn: (acc: T_28[], item: T_28, i: number, self: T_28[]) => T_28[], init: T_28[]) => any;
                                        flatMap: (fn: (item: T_28, i: number, self: T_28[]) => T_28[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_29>(value: Iterable<T_29>, type: IterTypes) => {
                                            value: string | Iterable<T_29> | Map<unknown, T_29>;
                                            map: (fn: (item: T_29, i: number, self: T_29[]) => T_29) => any;
                                            filter: (fn: (item: T_29, i: number, self: T_29[]) => boolean) => any;
                                            reduce: (fn: (acc: T_29[], item: T_29, i: number, self: T_29[]) => T_29[], init: T_29[]) => any;
                                            flatMap: (fn: (item: T_29, i: number, self: T_29[]) => T_29[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_30>(value: Iterable<T_30>, type: IterTypes) => any;
                                            unpack: <T_31>(fn: (item: T_29, i: number, self: T_29[]) => T_31) => T_31[];
                                            unique: () => any;
                                            asArr: T_29[];
                                            intersection: (other: Iterable<T_29>) => any;
                                        };
                                        unpack: <T_32>(fn: (item: T_28, i: number, self: T_28[]) => T_32) => T_32[];
                                        unique: () => any;
                                        asArr: T_28[];
                                        intersection: (other: Iterable<T_28>) => any;
                                    };
                                    unpack: <T_33>(fn: (item: T_27, i: number, self: T_27[]) => T_33) => T_33[];
                                    unique: () => any;
                                    asArr: T_27[];
                                    intersection: (other: Iterable<T_27>) => any;
                                };
                                unpack: <T_34>(fn: (item: T_26, i: number, self: T_26[]) => T_34) => T_34[];
                                unique: () => any;
                                asArr: T_26[];
                                intersection: (other: Iterable<T_26>) => any;
                            };
                            unpack: <T_35>(fn: (item: T_25, i: number, self: T_25[]) => T_35) => T_35[];
                            unique: () => any;
                            asArr: T_25[];
                            intersection: (other: Iterable<T_25>) => any;
                        };
                        unpack: <T_36>(fn: (item: T_24, i: number, self: T_24[]) => T_36) => T_36[];
                        unique: () => any;
                        asArr: T_24[];
                        intersection: (other: Iterable<T_24>) => any;
                    };
                    unpack: <T_37>(fn: (item: T_23, i: number, self: T_23[]) => T_37) => T_37[];
                    unique: () => any;
                    asArr: T_23[];
                    intersection: (other: Iterable<T_23>) => any;
                };
                unpack: <T_38>(fn: (item: T_22, i: number, self: T_22[]) => T_38) => T_38[];
                unique: () => any;
                asArr: T_22[];
                intersection: (other: Iterable<T_22>) => any;
            };
            unpack: <T_39>(fn: (item: T_21, i: number, self: T_21[]) => T_39) => T_39[];
            unique: () => any;
            asArr: T_21[];
            intersection: (other: Iterable<T_21>) => any;
        };
        unpack: <T_40>(fn: (item: T_20, i: number, self: T_20[]) => T_40) => T_40[];
        unique: () => any;
        asArr: T_20[];
        intersection: (other: Iterable<T_20>) => any;
    };
    unpack: <T_41>(fn: (item: V, i: number, self: V[]) => T_41) => T_41[];
    unique: () => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
    asArr: V[];
    intersection: (other: Iterable<V>) => {
        value: string | Iterable<V> | Map<unknown, V>;
        map: (fn: (item: V, i: number, self: V[]) => V) => any;
        filter: (fn: (item: V, i: number, self: V[]) => boolean) => any;
        reduce: (fn: (acc: V[], item: V, i: number, self: V[]) => V[], init: V[]) => any;
        flatMap: (fn: (item: V, i: number, self: V[]) => V[]) => any;
        slice: (start: number, end?: number) => any;
        currentType: IterTypes;
        unit: <T>(value: Iterable<T>, type: IterTypes) => {
            value: string | Iterable<T> | Map<unknown, T>;
            map: (fn: (item: T, i: number, self: T[]) => T) => any;
            filter: (fn: (item: T, i: number, self: T[]) => boolean) => any;
            reduce: (fn: (acc: T[], item: T, i: number, self: T[]) => T[], init: T[]) => any;
            flatMap: (fn: (item: T, i: number, self: T[]) => T[]) => any;
            slice: (start: number, end?: number) => any;
            currentType: IterTypes;
            unit: <T_1>(value: Iterable<T_1>, type: IterTypes) => {
                value: string | Iterable<T_1> | Map<unknown, T_1>;
                map: (fn: (item: T_1, i: number, self: T_1[]) => T_1) => any;
                filter: (fn: (item: T_1, i: number, self: T_1[]) => boolean) => any;
                reduce: (fn: (acc: T_1[], item: T_1, i: number, self: T_1[]) => T_1[], init: T_1[]) => any;
                flatMap: (fn: (item: T_1, i: number, self: T_1[]) => T_1[]) => any;
                slice: (start: number, end?: number) => any;
                currentType: IterTypes;
                unit: <T_2>(value: Iterable<T_2>, type: IterTypes) => {
                    value: string | Iterable<T_2> | Map<unknown, T_2>;
                    map: (fn: (item: T_2, i: number, self: T_2[]) => T_2) => any;
                    filter: (fn: (item: T_2, i: number, self: T_2[]) => boolean) => any;
                    reduce: (fn: (acc: T_2[], item: T_2, i: number, self: T_2[]) => T_2[], init: T_2[]) => any;
                    flatMap: (fn: (item: T_2, i: number, self: T_2[]) => T_2[]) => any;
                    slice: (start: number, end?: number) => any;
                    currentType: IterTypes;
                    unit: <T_3>(value: Iterable<T_3>, type: IterTypes) => {
                        value: string | Iterable<T_3> | Map<unknown, T_3>;
                        map: (fn: (item: T_3, i: number, self: T_3[]) => T_3) => any;
                        filter: (fn: (item: T_3, i: number, self: T_3[]) => boolean) => any;
                        reduce: (fn: (acc: T_3[], item: T_3, i: number, self: T_3[]) => T_3[], init: T_3[]) => any;
                        flatMap: (fn: (item: T_3, i: number, self: T_3[]) => T_3[]) => any;
                        slice: (start: number, end?: number) => any;
                        currentType: IterTypes;
                        unit: <T_4>(value: Iterable<T_4>, type: IterTypes) => {
                            value: string | Iterable<T_4> | Map<unknown, T_4>;
                            map: (fn: (item: T_4, i: number, self: T_4[]) => T_4) => any;
                            filter: (fn: (item: T_4, i: number, self: T_4[]) => boolean) => any;
                            reduce: (fn: (acc: T_4[], item: T_4, i: number, self: T_4[]) => T_4[], init: T_4[]) => any;
                            flatMap: (fn: (item: T_4, i: number, self: T_4[]) => T_4[]) => any;
                            slice: (start: number, end?: number) => any;
                            currentType: IterTypes;
                            unit: <T_5>(value: Iterable<T_5>, type: IterTypes) => {
                                value: string | Iterable<T_5> | Map<unknown, T_5>;
                                map: (fn: (item: T_5, i: number, self: T_5[]) => T_5) => any;
                                filter: (fn: (item: T_5, i: number, self: T_5[]) => boolean) => any;
                                reduce: (fn: (acc: T_5[], item: T_5, i: number, self: T_5[]) => T_5[], init: T_5[]) => any;
                                flatMap: (fn: (item: T_5, i: number, self: T_5[]) => T_5[]) => any;
                                slice: (start: number, end?: number) => any;
                                currentType: IterTypes;
                                unit: <T_6>(value: Iterable<T_6>, type: IterTypes) => {
                                    value: string | Iterable<T_6> | Map<unknown, T_6>;
                                    map: (fn: (item: T_6, i: number, self: T_6[]) => T_6) => any;
                                    filter: (fn: (item: T_6, i: number, self: T_6[]) => boolean) => any;
                                    reduce: (fn: (acc: T_6[], item: T_6, i: number, self: T_6[]) => T_6[], init: T_6[]) => any;
                                    flatMap: (fn: (item: T_6, i: number, self: T_6[]) => T_6[]) => any;
                                    slice: (start: number, end?: number) => any;
                                    currentType: IterTypes;
                                    unit: <T_7>(value: Iterable<T_7>, type: IterTypes) => {
                                        value: string | Iterable<T_7> | Map<unknown, T_7>;
                                        map: (fn: (item: T_7, i: number, self: T_7[]) => T_7) => any;
                                        filter: (fn: (item: T_7, i: number, self: T_7[]) => boolean) => any;
                                        reduce: (fn: (acc: T_7[], item: T_7, i: number, self: T_7[]) => T_7[], init: T_7[]) => any;
                                        flatMap: (fn: (item: T_7, i: number, self: T_7[]) => T_7[]) => any;
                                        slice: (start: number, end?: number) => any;
                                        currentType: IterTypes;
                                        unit: <T_8>(value: Iterable<T_8>, type: IterTypes) => {
                                            value: string | Iterable<T_8> | Map<unknown, T_8>;
                                            map: (fn: (item: T_8, i: number, self: T_8[]) => T_8) => any;
                                            filter: (fn: (item: T_8, i: number, self: T_8[]) => boolean) => any;
                                            reduce: (fn: (acc: T_8[], item: T_8, i: number, self: T_8[]) => T_8[], init: T_8[]) => any;
                                            flatMap: (fn: (item: T_8, i: number, self: T_8[]) => T_8[]) => any;
                                            slice: (start: number, end?: number) => any;
                                            currentType: IterTypes;
                                            unit: <T_9>(value: Iterable<T_9>, type: IterTypes) => any;
                                            unpack: <T_10>(fn: (item: T_8, i: number, self: T_8[]) => T_10) => T_10[];
                                            unique: () => any;
                                            asArr: T_8[];
                                            intersection: (other: Iterable<T_8>) => any;
                                        };
                                        unpack: <T_11>(fn: (item: T_7, i: number, self: T_7[]) => T_11) => T_11[];
                                        unique: () => any;
                                        asArr: T_7[];
                                        intersection: (other: Iterable<T_7>) => any;
                                    };
                                    unpack: <T_12>(fn: (item: T_6, i: number, self: T_6[]) => T_12) => T_12[];
                                    unique: () => any;
                                    asArr: T_6[];
                                    intersection: (other: Iterable<T_6>) => any;
                                };
                                unpack: <T_13>(fn: (item: T_5, i: number, self: T_5[]) => T_13) => T_13[];
                                unique: () => any;
                                asArr: T_5[];
                                intersection: (other: Iterable<T_5>) => any;
                            };
                            unpack: <T_14>(fn: (item: T_4, i: number, self: T_4[]) => T_14) => T_14[];
                            unique: () => any;
                            asArr: T_4[];
                            intersection: (other: Iterable<T_4>) => any;
                        };
                        unpack: <T_15>(fn: (item: T_3, i: number, self: T_3[]) => T_15) => T_15[];
                        unique: () => any;
                        asArr: T_3[];
                        intersection: (other: Iterable<T_3>) => any;
                    };
                    unpack: <T_16>(fn: (item: T_2, i: number, self: T_2[]) => T_16) => T_16[];
                    unique: () => any;
                    asArr: T_2[];
                    intersection: (other: Iterable<T_2>) => any;
                };
                unpack: <T_17>(fn: (item: T_1, i: number, self: T_1[]) => T_17) => T_17[];
                unique: () => any;
                asArr: T_1[];
                intersection: (other: Iterable<T_1>) => any;
            };
            unpack: <T_18>(fn: (item: T, i: number, self: T[]) => T_18) => T_18[];
            unique: () => any;
            asArr: T[];
            intersection: (other: Iterable<T>) => any;
        };
        unpack: <T_19>(fn: (item: V, i: number, self: V[]) => T_19) => T_19[];
        unique: () => any;
        asArr: V[];
        intersection: (other: Iterable<V>) => any;
    };
};
export {};
//# sourceMappingURL=Iterable.d.ts.map