import { AsyncSequence } from "./AsyncSequence";
import { Sequence } from "./Sequence";
export { Sequence, Sequence as default } from "./Sequence";
export { AsyncSequence } from "./AsyncSequence";
export { default as Comparator } from "./Comparator";
export { default as ComparatorFactory } from "./ComparatorFactory";
export { default as IndexedValue } from "./IndexedValue";
export { JoinConfig as JoinToStringConfig } from "./operators/sync/joinToString";
export { JoinConfig as AsyncJoinToStringConfig } from "./operators/async/joinToString";
/**
 * Create sequence of multiple arguments of an array of arguments
 * @param {...T} args Arguments
 * @returns Sequence
 * @example
 * // Sequence<number>
 * sequenceOf(1, 2, 3);
 * // Sequence<number>
 * sequenceOf([1, 2, 3]);
 */
export declare function sequenceOf<T>(...args: T[]): Sequence<T>;
/**
 * Create async sequence of multiple arguments of an array of arguments
 * @param {...T} args Arguments
 * @returns AsyncSequence
 * @example
 * asyncSequenceOf(1, 2, 3); // AsyncSequence<number>
 * asyncSequenceOf([1, 2, 3]); // AsyncSequence<number>
 */
export declare function asyncSequenceOf<T>(...args: T[]): AsyncSequence<T>;
/**
 * Create empty sequence
 * @returns Sequence
 */
export declare function emptySequence<T>(): Sequence<T>;
/**
 * Create empty async sequence
 * @returns AsyncSequence
 */
export declare function emptyAsyncSequence<T>(): AsyncSequence<T>;
/**
 * Create sequence for iterable object / generator
 * @param {Iterable<T>} iterable Iterable object / generator
 * @returns Sequence
 * @example
 * // Sequence<number> => 1, 2, 3
 * asSequence([1, 2, 3]);
 * // Sequence<number> => 1, 2, 3
 * asSequence(new Set([1, 2, 3]));
 * // Sequence<[string, number]> => ["a", 1], ["b", 2], ["c", 3]
 * asSequence(new Map([["a", 1], ["b", 2], ["c", 3]]));
 * // Sequence<string> => "a", "b", "c"
 * asSequence("abc");
 * // Sequence<number> => 0, 1, 2, 3, ...
 * asSequence((function* () {
 *     let i = 0;
 *     while (true) {
 *         yield i++;
 *     }
 * })());
 */
export declare function asSequence<T>(iterable: Iterable<T>): Sequence<T>;
/**
 * Create async sequence for iterable object / generator
 * @param {Iterable<T> | AsyncIterable<T>} iterable Iterable object / generator
 * @returns AsyncSequence
 * @example
 * // AsyncSequence<number> => 1, 2, 3
 * asAsyncSequence([1, 2, 3]);
 * // AsyncSequence<number> => 1, 2, 3
 * asAsyncSequence(new Set([1, 2, 3]));
 * // AsyncSequence<[string, number]> => ["a", 1], ["b", 2], ["c", 3]
 * asAsyncSequence(new Map([["a", 1], ["b", 2], ["c", 3]]));
 * // AsyncSequence<string> => "a", "b", "c"
 * asAsyncSequence("abc");
 * // AsyncSequence<number> => 0, 1, 2, 3, ...
 * asAsyncSequence((async function* () {
 *     let i = 0;
 *     while (true) {
 *         yield i++;
 *     }
 * })());
 */
export declare function asAsyncSequence<T>(iterable: Iterable<T> | AsyncIterable<T>): AsyncSequence<T>;
/**
 * Create sequence for iterator
 * @param {Iterator<T>} iterator Iterator
 * @returns Sequence
 * @example
 * // Sequence<unknown>
 * createSequence({
 *     next(value) {
 *         return {done: true, value: null};
 *     }
 * });
 */
export declare function createSequence<T>(iterator: Iterator<T>): Sequence<T>;
/**
 * Create async sequence for async iterator
 * @param {AsyncIterator<T>} iterator AsyncIterator
 * @returns AsyncSequence
 * @example
 * // Sequence<unknown>
 * createAsyncSequence({
 *     async next(value) {
 *         return {done: true, value: null};
 *     }
 * });
 */
export declare function createAsyncSequence<T>(iterator: AsyncIterator<T>): AsyncSequence<T>;
/**
 * Check if an object is a sequence
 * @param {unknown} object Object of interest
 * @returns Whether it is or not
 */
export declare function isSequence<T>(object: unknown): object is Sequence<T>;
/**
 * Check if an object is an async sequence
 * @param {unknown} object Object of interest
 * @returns Whether it is or not
 */
export declare function isAsyncSequence<T>(object: unknown): object is AsyncSequence<T>;
/**
 * Extend the basic sequence implementation
 * @param {{new(): any}} mixin Mixin operators
 */
export declare function extendSequence(mixin: {
    new (): any;
}): void;
/**
 * Extend the basic async sequence implementation
 * @param {{new(): any}} mixin Mixin operators
 */
export declare function extendAsyncSequence(mixin: {
    new (): any;
}): void;
/**
 * Generate a sequence
 * @param nextFunction Function to generate next value with (null/undefined to end sequence)
 * @example
 * // Sequence<number> => 0, 1, ..., 8, 9
 * let i = 0;
 * generateSequence(() => count < 10 ? count++ : null);
 */
export declare function generateSequence<T>(nextFunction: () => T | null | undefined): Sequence<T>;
/**
 * Generate a sequence
 * @param seedFunction Function to generate initial value with (seed)
 * @param nextFunction Function to generate next value with (null/undefined to end sequence)
 * @example
 * // Sequence<number> => 0, 1, ..., 8, 9
 * generateSequence(() => 0, value => value < 10 ? value + 1 : null);
 */
export declare function generateSequence<T>(seedFunction: () => T | null | undefined, nextFunction: (item: T) => T | null | undefined): Sequence<T>;
/**
 * Generate a sequence
 * @param seed Initial value (seed)
 * @param nextFunction Function to generate next value with (null/undefined to end sequence)
 * @example
 * // Sequence<number> => 0, 1, ..., 8, 9
 * generateSequence(0, value => value < 10 ? value + 1 : null);
 */
export declare function generateSequence<T>(seed: T | null | undefined, nextFunction: (item: T) => T | null | undefined): Sequence<T>;
/**
 * Generate sequence from range
 * @param start Range start
 * @param endInclusive Range end (inclusive)
 * @param step Step size
 * @returns Sequence
 * @example
 * // Sequence<number> => 0, 1, 2, 3, 4
 * range(0, 4);
 * // Sequence<number> => 0, 0.5, 1, ..., 3.5, 4
 * range(0, 4, 0.5);
 */
export declare function range(start: number, endInclusive: number, step?: number): Sequence<number>;
/**
 * Creates a tuple from the given arguments, preserving tuple types for better type inference.
 * Useful when working with sequences that need to maintain tuple types, especially when using `toMap`.
 *
 * @param {...T} args Arguments to create a tuple from
 * @returns Tuple of the arguments
 * @example
 * // Preserves tuple type [string, number] instead of (string | number)[]
 * const result = sequenceOf(["a", 1], ["b", 2])
 *   .mapNotNull(([key, value]) => value > 0 ? tuple(key, value) : null)
 *   .toMap();
 * // result: Map<string, number>
 */
export declare const tuple: <T extends any[]>(...args: T) => T;