/**
 * High-performance Sequence class for managing collections of Period instances
 * Optimized for large datasets with efficient gap analysis and set operations
 */
import { Period } from '../core/Period';
export declare class Sequence implements Iterable<Period> {
    private readonly _periods;
    private readonly _sorted;
    private _boundaries?;
    private _gaps?;
    private _totalDuration?;
    private _sortedByStart?;
    private _sortedByEnd?;
    private _sortedByDuration?;
    private _isEmpty?;
    private _count?;
    private _cacheHash?;
    constructor(periods: Period[], preserveOrder: boolean);
    constructor(...periods: Period[]);
    /**
     * Create sequence from array of periods
     * Optimized constructor for better performance with large arrays
     */
    static fromArray(periods: Period[]): Sequence;
    /**
     * Create empty sequence
     * Optimized for common use case
     */
    static empty(): Sequence;
    /**
     * Number of periods in the sequence (cached)
     * O(1) operation with memoization
     */
    count(): number;
    /**
     * Check if sequence is empty (cached)
     * O(1) operation with memoization
     */
    isEmpty(): boolean;
    /**
     * Get period by index
     * O(1) operation with bounds checking
     */
    get(index: number): Period;
    /**
     * Get first period
     * O(1) operation
     */
    first(): Period | undefined;
    /**
     * Get last period
     * O(1) operation
     */
    last(): Period | undefined;
    /**
     * Convert to array
     * Returns a copy to maintain immutability
     */
    toArray(): Period[];
    /**
     * Iterator implementation for for...of loops
     * Enables: for (const period of sequence) { ... }
     */
    [Symbol.iterator](): IterableIterator<Period>;
    /**
     * Get boundaries of the entire sequence
     * Returns a period that spans from the earliest start to the latest end
     * Cached for performance
     */
    boundaries(): Period | undefined;
    /**
     * Find gaps between non-overlapping periods
     * Returns a new Sequence containing the gap periods
     * Highly optimized algorithm with O(n) complexity
     */
    gaps(): Sequence;
    /**
     * Filter periods based on predicate
     * Returns new Sequence with matching periods
     */
    filter(predicate: (period: Period, index: number) => boolean): Sequence;
    /**
     * Map periods to new values
     * Returns array of mapped values
     */
    map<T>(mapper: (period: Period, index: number) => T): T[];
    /**
     * Check if any period matches the predicate
     */
    some(predicate: (period: Period, index: number) => boolean): boolean;
    /**
     * Check if all periods match the predicate
     */
    every(predicate: (period: Period, index: number) => boolean): boolean;
    /**
     * Find first period matching predicate
     */
    find(predicate: (period: Period, index: number) => boolean): Period | undefined;
    /**
     * Reduce sequence to a single value
     * Standard array reduce functionality
     */
    reduce<T>(reducer: (accumulator: T, period: Period, index: number, array: readonly Period[]) => T, initialValue: T): T;
    /**
     * Sort sequence by custom comparator
     * Returns new Sequence with sorted periods
     */
    sort(compareFn?: (a: Period, b: Period) => number): Sequence;
    /**
     * Sort by start date (already optimized as default)
     * Returns this sequence if already sorted by start date
     */
    sortByStartDate(): Sequence;
    /**
     * Sort by duration (shortest first)
     * Returns new Sequence sorted by duration
     */
    sortByDuration(): Sequence;
    /**
     * Check if this sequence equals another sequence
     * Compares all periods for equality
     */
    equals(other: Sequence): boolean;
    /**
     * String representation of the sequence
     * Shows count and boundaries for debugging
     */
    toString(): string;
    /**
     * Create a union of this sequence with another sequence
     * Combines all periods from both sequences, removing duplicates
     * @param other - The sequence to union with
     * @returns A new sequence containing all unique periods from both sequences
     */
    union(other: Sequence): Sequence;
    /**
     * Find intersections with another sequence
     * Returns periods that overlap between this sequence and another
     * @param other - The sequence to intersect with
     * @returns A new sequence containing only overlapping periods
     */
    intersect(other: Sequence): Sequence;
    /**
     * Subtract operation - remove overlapping periods
     * High-performance implementation with early termination
     * Complexity: O(n * m) but optimized with early breaks
     */
    subtract(other: Sequence): Sequence;
    /**
     * Merge overlapping and consecutive day periods within this sequence
     * Optimized for date-only operations with enhanced boundary logic
     * Complexity: O(n) since periods are already sorted
     */
    merge(): Sequence;
    /**
     * Get the total duration of all periods in the sequence (cached)
     * Ultra-optimized calculation with memoization
     */
    totalDuration(): number;
    /**
     * Add a period to the end of the sequence
     * Returns a new Sequence instance (immutable design)
     */
    push(period: Period): Sequence;
    /**
     * Add a period to the beginning of the sequence
     * Returns a new Sequence instance (immutable design)
     */
    unshift(period: Period): Sequence;
    /**
     * Insert a period at the specified index
     * Returns a new Sequence instance (immutable design)
     * @param index - Zero-based index (supports negative indexing)
     * @param period - Period to insert
     */
    insert(index: number, period: Period): Sequence;
    /**
     * Remove and return the period at the specified index
     * Returns the removed period, and updates this sequence to a new instance
     * @param index - Zero-based index (supports negative indexing)
     */
    remove(index: number): Period;
    /**
     * Replace the period at the specified index
     * Returns a new Sequence instance (immutable design)
     * @param index - Zero-based index (supports negative indexing)
     * @param period - New period to set
     */
    set(index: number, period: Period): Sequence;
    /**
     * Remove all periods from the sequence
     * Returns a new empty Sequence instance (immutable design)
     */
    clear(): Sequence;
    /**
     * Check if the sequence contains a specific period
     * @param period - Period to search for
     */
    contains(period: Period): boolean;
    /**
     * Find the index of a specific period in the sequence
     * @param period - Period to search for
     * @returns Index of the period, or false if not found
     */
    indexOf(period: Period): number | false;
    /**
     * Convert sequence to array (alias for toArray for compatibility)
     */
    toList(): Period[];
}
//# sourceMappingURL=Sequence.d.ts.map