import { ObjectLike } from "./ObjectTypes";
export type ObjectValueIteratorValueGenerator<T extends ObjectLike<T>, R> = (obj: T, key: keyof T, value: T[keyof T], index: number) => R;
export type ObjectEntries<T extends ObjectLike<T>> = [
    keyof T,
    T[keyof T],
    number
];
export type IteratorStepOptions = {
    start?: number;
    end?: number;
    step?: number;
};
/**
 * `ObjectValueIterator` is an iterator for objects (Stronly typed)
 * This is the base class for other objects iterators.
 *
 * This base takes a value generator function that is called for each value when iterating
 *
 * @example
 * export class ObjectEntiresIterator<T extends object> extends ObjectValueIterator<T, [keyof T, T[keyof T]]>
 * {
 *   constructor(obj: T) {
 *     // This generator returns the [key, value] as a tuple
 *     super(obj, (obj, key, value) => [key, value])
 *   }
 * }
 * export class ObjectKeysIterator<T extends object> extends ObjectValueIterator<keyof T>
 * {
 *   constructor(obj: T) {
 *     // This generator returns the only the key
 *     super(obj, (obj, key, value) => key)
 *   }
 * }
 *
 * @see Also see {@link ObjectEntriesIterator}, {@link ObjectKeysIterator} and {@link ObjectValuesIterator}
 */
export declare class ObjectValueIterator<T extends ObjectLike<T>, TReturnValue> implements Iterable<TReturnValue> {
    private index;
    private done;
    private end;
    private step;
    private keys;
    private readonly obj;
    private readonly valueGenerator;
    constructor(obj: T, valueGenerator: ObjectValueIteratorValueGenerator<T, TReturnValue>, stepOptions?: IteratorStepOptions);
    next(): IteratorResult<TReturnValue>;
    /**
     * change the start index (to skip values)
     * @param count
     * @returns
     */
    skip(count: number): this;
    /**
     * change the end index (to stop the iterator)
     * @param count
     * @returns
     */
    limit(count: number): this;
    /**
     * change the step (to skip values)
     * @param step
     * @returns
     */
    stepBy(step: number): this;
    /**
     * set end index (to stop the iterator)
     * @param end
     * @returns
     */
    stopAt(end: number): this;
    /**
     * stop the iterator
     * @returns
     */
    stop(): this;
    /**
     * forEach the values of the iterator (value, key, index)
     * @param callback
     */
    forEach(callback: (value: TReturnValue, index: number) => void | false): void;
    /**
     * map the values of the iterator to an array
     * @param mapper
     * @param filterNull If true, mapped null values will be filtered out [default: true]
     * @returns
     */
    map<R>(mapper: (value: TReturnValue, index: number, outArr: R[]) => R | null, filterNull?: boolean): R[];
    /**
     * flatMap the values of the iterator to an array
     * @param mapper
     * @param filterNull
     * @returns
     */
    flatMap<R>(mapper: (value: TReturnValue, index: number, outArr: R[]) => R | R[] | null, filterNull?: boolean): R[];
    /**
     * reduce the values of the iterator to a single value
     * @param init
     * @param reducer
     * @returns
     */
    reduce<R>(init: R, reducer: (acc: R, value: TReturnValue, index: number) => R): R;
    [Symbol.iterator](): ObjectValueIterator<T, TReturnValue>;
}
/**
 * `ObjectEntiresIterator` is an iterator for objects (Stronly typed)
 */
export declare class ObjectEntriesIterator<T extends ObjectLike<T>> extends ObjectValueIterator<T, [
    keyof T,
    T[keyof T],
    number
]> {
    constructor(obj: T, stepOptions?: IteratorStepOptions);
}
/**
 * `ObjectKeysIterator` is an iterator for object keys (Stronly typed)
 */
export declare class ObjectKeysIterator<T extends ObjectLike<T>> extends ObjectValueIterator<T, keyof T> {
    constructor(obj: T, stepOptions?: IteratorStepOptions);
}
/**
 * `ObjectValuesIterator` is an iterator for object values (Stronly typed)
 */
export declare class ObjectValuesIterator<T extends ObjectLike<T>> extends ObjectValueIterator<T, T[keyof T]> {
    constructor(obj: T, stepOptions?: IteratorStepOptions);
}
export declare function entries<T extends ObjectLike<T>>(obj: T, stepOptions?: IteratorStepOptions): ObjectEntriesIterator<T>;
export declare function keys<T extends ObjectLike<T>>(obj: T, stepOptions?: IteratorStepOptions): ObjectKeysIterator<T>;
export declare function values<T extends ObjectLike<T>>(obj: T, stepOptions?: IteratorStepOptions): ObjectValuesIterator<T>;
export declare function reduce<R, T extends ObjectLike<T>>(obj: T, acc: R, reducer: (acc: R, key: keyof T, value: T[keyof T], index: number) => R): R;
export declare function reduceObj<R, T extends ObjectLike<T>>(obj: T, reducer: (acc: R, key: keyof T, value: T[keyof T]) => R): R;
export declare function map<T extends ObjectLike<T>, R>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => R): R[];
export declare const Iterate: {
    entries: typeof entries;
    keys: typeof keys;
    values: typeof values;
    reduce: typeof reduce;
    reduceObj: typeof reduceObj;
    map: typeof map;
};
export default Iterate;